Merge branch 'master'

SampleScenes/Common/Shaders/CubemapColorMap.shader

-Shader "Hidden/CubemapColorMap" {
+Shader "Hidden/CubemapColorMap" {
     Properties {
         _ColorMap("Color", Cube) = "white" {}
         _MipIndex("Mip Index", Int) = 0

ScriptableRenderPipeline/Core/Editor/ShaderGenerator/CSharpToHLSL.cs

+using System;
 using ICSharpCode.NRefactory;
 using ICSharpCode.NRefactory.Visitors;
 using ICSharpCode.NRefactory.Ast;
             s_TypeName = new Dictionary<string, ShaderTypeGenerator>();
 
             // Iterate over assemblyList, discover all applicable types with fully qualified names
-            var assemblyList = AssemblyEnumerator.EnumerateReferencedAssemblies(Assembly.GetCallingAssembly());
+            var assemblyList = AppDomain.CurrentDomain.GetAssemblies().ToList();
 
             foreach (var assembly in assemblyList)
             {
                 return null;
             }
         }
-    }
-
-    // Helper class to recursively enumerate assemblies referenced by the calling assembly, including unloaded ones
-    static class AssemblyEnumerator
-    {
-        public static List<Assembly> EnumerateReferencedAssemblies(Assembly assembly)
-        {
-            Dictionary<string, Assembly> referenced = assembly.GetReferencedAssembliesRecursive();
-            referenced[GetName(assembly.FullName)] = assembly;
-            return referenced.Values.ToList();
-        }
-
-        public static Dictionary<string, Assembly> GetReferencedAssembliesRecursive(this Assembly assembly)
-        {
-            s_Assemblies = new Dictionary<string, Assembly>();
-            InternalGetDependentAssembliesRecursive(assembly);
-
-            // Skip assemblies from GAC (@TODO:  any reason we'd want to include them?)
-            var keysToRemove = s_Assemblies.Values.Where(
-                    o => o.GlobalAssemblyCache == true).ToList();
-
-            foreach (var k in keysToRemove)
-            {
-                s_Assemblies.Remove(GetName(k.FullName));
-            }
-
-            return s_Assemblies;
-        }
-
-        private static void InternalGetDependentAssembliesRecursive(Assembly assembly)
-        {
-            // Load assemblies with newest versions first.
-            var referencedAssemblies = assembly.GetReferencedAssemblies()
-                .OrderByDescending(o => o.Version);
-
-            foreach (var r in referencedAssemblies)
-            {
-                if (string.IsNullOrEmpty(assembly.FullName))
-                {
-                    continue;
-                }
-
-                if (s_Assemblies.ContainsKey(GetName(r.FullName)))
-                    continue;
-
-                try
-                {
-                    // Ensure that the assembly is loaded
-                    var a = Assembly.Load(r.FullName);
-                    s_Assemblies[GetName(a.FullName)] = a;
-                    InternalGetDependentAssembliesRecursive(a);
-                }
-                catch
-                {
-                    // Missing dll, ignore.
-                }
-            }
-        }
-
-        static string GetName(string name)
-        {
-            return name.Split(',')[0];
-        }
-
-        static Dictionary<string, Assembly> s_Assemblies;
     }
 }

ScriptableRenderPipeline/Core/Editor/Volume/VolumeEditor.cs

                 actualTarget.isDirty = false;
             }
 
-            using (var scope = new EditorGUILayout.VerticalScope())
+            using (var vscope = new EditorGUILayout.VerticalScope())
             {
                 EditorGUILayout.PropertyField(m_IsGlobal);
 
                 if (m_Editors.Count > 0)
                     CoreEditorUtils.DrawSplitter();
                 else
-                    EditorGUILayout.HelpBox("No override set on this volume.", MessageType.Info);
+                    EditorGUILayout.HelpBox("No override set on this volume. Drop a component here or use the Add button.", MessageType.Info);
-                using (new EditorGUILayout.HorizontalScope())
-                {
-                    GUILayout.FlexibleSpace();
+                EditorGUILayout.Space();
-                    //if (GUILayout.Button(CoreEditorUtils.GetContent("Add Component"), GUILayout.Width(230f), GUILayout.Height(24f)))
-                    //{
+                using (var hscope = new EditorGUILayout.HorizontalScope())
+                {
+                    if (GUILayout.Button(CoreEditorUtils.GetContent("Add component overrides..."), EditorStyles.miniButton))
+                    {
+                        var r = hscope.rect;
+                        var pos = new Vector2(r.x + r.width / 2f, r.yMax + 18f);
+                        FilterWindow.Show(pos, new VolumeComponentProvider(actualTarget, this));
+                    }
+                }
-                    //}
-
-                    GUILayout.FlexibleSpace();
-                }
+                EditorGUILayout.Space();
-                    if (IsDragValid(scope.rect, e.mousePosition))
+                    if (IsDragValid(vscope.rect, e.mousePosition))
                     {
                         DragAndDrop.visualMode = DragAndDropVisualMode.Link;
                         e.Use();
                 }
                 else if (e.type == EventType.DragPerform)
                 {
-                    if (IsDragValid(scope.rect, e.mousePosition))
+                    if (IsDragValid(vscope.rect, e.mousePosition))
                     {
                         DragAndDrop.AcceptDrag();
 
         }
 
         // index is only used when we need to re-create a component in a specific spot (e.g. reset)
-        void CreateEditor(VolumeComponent settings, SerializedProperty property, int index = -1)
+        void CreateEditor(VolumeComponent settings, SerializedProperty property, int index = -1, bool forceOpen = false)
         {
             var settingsType = settings.GetType();
             Type editorType;
             var editor = (VolumeComponentEditor)Activator.CreateInstance(editorType);
             editor.Init(settings, this);
             editor.baseProperty = property.Copy();
+
+            if (forceOpen)
+                editor.baseProperty.isExpanded = true;
 
             if (index < 0)
                 m_Editors.Add(editor);
 
-        void AddComponent(Type type)
+        internal void AddComponent(Type type)
         {
             serializedObject.Update();
 
             effectProp.objectReferenceValue = component;
 
             // Create & store the internal editor object for this effect
-            CreateEditor(component, effectProp);
+            CreateEditor(component, effectProp, forceOpen: true);
-        void RemoveComponent(int id)
+        internal void RemoveComponent(int id)
         {
             // Huh. Hack to keep foldout state on the next element...
             bool nextFoldoutState = false;
 
         // Reset is done by deleting and removing the object from the list and adding a new one in
         // the same spot as it was before
-        void ResetComponent(Type type, int id)
+        internal void ResetComponent(Type type, int id)
         {
             // Remove from the cached editors list
             m_Editors[id].OnDisable();
             Undo.DestroyObjectImmediate(prevSettings);
         }
 
-        void MoveComponent(int id, int offset)
+        internal void MoveComponent(int id, int offset)
         {
             // Move components
             serializedObject.Update();

ScriptableRenderPipeline/Core/Resources/EncodeBC6H.compute

-#include "ShaderLibrary/Common.hlsl"
+#include "ShaderLibrary/Common.hlsl"
-#include "ShaderLibrary/Sampling.hlsl"
+#include "ShaderLibrary/Sampling/Sampling.hlsl"
-SamplerState s_point_clamp;
+SAMPLER(s_point_clamp);
 
 static const uint2 kOffsets[] =
 {
     {
         nvc = CubemapTexelToNVC(topLeftSourceID + kOffsets[i], size);
         dir = CubemapTexelToDirection(nvc, faceId);
-        texels[i] = _Source.SampleLevel(s_point_clamp, dir, _MipIndex).rgb;
+        texels[i] = SAMPLE_TEXTURECUBE_LOD(_Source, s_point_clamp, dir, _MipIndex).rgb;
     }
 
     uint4 block = uint4(0, 0, 0, 0);

ScriptableRenderPipeline/Core/Resources/GPUCopy.compute

 
 RWTexture2D<float1> _Result1;
 
-Texture2D<float4> _Source4;
+TEXTURE2D(_Source4);
 
 
 #pragma kernel KSampleCopy4_1_x
-    _Result1[dispatchThreadId] = _Source4.SampleLevel(sampler_LinearClamp, float2(dispatchThreadId) * _Size.zw, 0.0).x;
+    _Result1[dispatchThreadId] = SAMPLE_TEXTURE2D_LOD(_Source4, sampler_LinearClamp, float2(dispatchThreadId) * _Size.zw, 0.0).x;
 }
 
 

ScriptableRenderPipeline/Core/Resources/GPUCopy.compute.meta

 fileFormatVersion: 2
-guid: a68d8aaeb0956234d94e389f196381ee
-timeCreated: 1507123133
-licenseType: Pro
+guid: a4d45eda75e8e474dbe24a31f741f3b4
 ComputeShaderImporter:
   externalObjects: {}
   currentAPIMask: 4

ScriptableRenderPipeline/Core/Resources/GPUCopyAsset.cs

-using System;
+using System;
 using System.Collections.Generic;
 using System.Text;
 
                     k_KernelSize.ToString(), k_KernelSize.ToString()));
                 cck.AppendLine(string.Format(@"void {0}(uint2 dispatchThreadId : SV_DispatchThreadID)", kernelName));
                 cck.AppendLine("{");
-                cck.AppendLine(string.Format("    _Result{0}[dispatchThreadId] = _Source{1}.SampleLevel(sampler_LinearClamp, float2(dispatchThreadId) * _Size.zw, 0.0).{2};",
+                cck.AppendLine(string.Format("    _Result{0}[dispatchThreadId] = SAMPLE_TEXTURE2D_LOD(_Source{1}, sampler_LinearClamp, float2(dispatchThreadId) * _Size.zw, 0.0).{2};",
                     o.targetChannel.ToString(), o.sourceChannel.ToString(), o.subscript));
                 cck.AppendLine("}");
                 cck.AppendLine();

ScriptableRenderPipeline/Core/ShaderLibrary/API/D3D11.hlsl

 #define GATHER_TEXTURE2D_ARRAY(textureName, samplerName, coord2, index)   textureName.Gather(samplerName, float3(coord2, index))
 #define GATHER_TEXTURECUBE(textureName, samplerName, coord3)              textureName.Gather(samplerName, coord3)
 #define GATHER_TEXTURECUBE_ARRAY(textureName, samplerName, coord3, index) textureName.Gather(samplerName, float4(coord3, index))
+
+#define GATHER_RED_TEXTURE2D(textureName, samplerName, coord2)              textureName.GatherRed(samplerName, coord2)
+#define GATHER_GREEN_TEXTURE2D(textureName, samplerName, coord2)            textureName.GatherGreen(samplerName, coord2)
+#define GATHER_BLUE_TEXTURE2D(textureName, samplerName, coord2)             textureName.GatherBlue(samplerName, coord2)

ScriptableRenderPipeline/Core/ShaderLibrary/API/Metal.hlsl

 #define GATHER_TEXTURE2D_ARRAY(textureName, samplerName, coord2, index)   textureName.Gather(samplerName, float3(coord2, index))
 #define GATHER_TEXTURECUBE(textureName, samplerName, coord3)              textureName.Gather(samplerName, coord3)
 #define GATHER_TEXTURECUBE_ARRAY(textureName, samplerName, coord3, index) textureName.Gather(samplerName, float4(coord3, index))
+
+#define GATHER_RED_TEXTURE2D(textureName, samplerName, coord2)              textureName.GatherRed(samplerName, coord2)
+#define GATHER_GREEN_TEXTURE2D(textureName, samplerName, coord2)            textureName.GatherGreen(samplerName, coord2)
+#define GATHER_BLUE_TEXTURE2D(textureName, samplerName, coord2)             textureName.GatherBlue(samplerName, coord2)

ScriptableRenderPipeline/Core/ShaderLibrary/API/PSSL.hlsl

 #define GATHER_TEXTURE2D_ARRAY(textureName, samplerName, coord2, index)   textureName.Gather(samplerName, float3(coord2, index))
 #define GATHER_TEXTURECUBE(textureName, samplerName, coord3)              textureName.Gather(samplerName, coord3)
 #define GATHER_TEXTURECUBE_ARRAY(textureName, samplerName, coord3, index) textureName.Gather(samplerName, float4(coord3, index))
+
+#define GATHER_RED_TEXTURE2D(textureName, samplerName, coord2)              textureName.GatherRed(samplerName, coord2)
+#define GATHER_GREEN_TEXTURE2D(textureName, samplerName, coord2)            textureName.GatherGreen(samplerName, coord2)
+#define GATHER_BLUE_TEXTURE2D(textureName, samplerName, coord2)             textureName.GatherBlue(samplerName, coord2)

ScriptableRenderPipeline/Core/ShaderLibrary/API/Vulkan.hlsl

 #define GATHER_TEXTURE2D_ARRAY(textureName, samplerName, coord2, index)   textureName.Gather(samplerName, float3(coord2, index))
 #define GATHER_TEXTURECUBE(textureName, samplerName, coord3)              textureName.Gather(samplerName, coord3)
 #define GATHER_TEXTURECUBE_ARRAY(textureName, samplerName, coord3, index) textureName.Gather(samplerName, float4(coord3, index))
+
+#define GATHER_RED_TEXTURE2D(textureName, samplerName, coord2)              textureName.GatherRed(samplerName, coord2)
+#define GATHER_GREEN_TEXTURE2D(textureName, samplerName, coord2)            textureName.GatherGreen(samplerName, coord2)
+#define GATHER_BLUE_TEXTURE2D(textureName, samplerName, coord2)             textureName.GatherBlue(samplerName, coord2)

ScriptableRenderPipeline/Core/ShaderLibrary/API/XBoxOne.hlsl

 #define GATHER_TEXTURE2D_ARRAY(textureName, samplerName, coord2, index)   textureName.Gather(samplerName, float3(coord2, index))
 #define GATHER_TEXTURECUBE(textureName, samplerName, coord3)              textureName.Gather(samplerName, coord3)
 #define GATHER_TEXTURECUBE_ARRAY(textureName, samplerName, coord3, index) textureName.Gather(samplerName, float4(coord3, index))
+
+#define GATHER_RED_TEXTURE2D(textureName, samplerName, coord2)              textureName.GatherRed(samplerName, coord2)
+#define GATHER_GREEN_TEXTURE2D(textureName, samplerName, coord2)            textureName.GatherGreen(samplerName, coord2)
+#define GATHER_BLUE_TEXTURE2D(textureName, samplerName, coord2)             textureName.GatherBlue(samplerName, coord2)

ScriptableRenderPipeline/Core/ShaderLibrary/Color.hlsl

     return dot(linearRgb, float3(0.2126729f, 0.7151522f, 0.0721750f));
 }
 
+float Luminance(float4 linearRgba)
+{
+    return Luminance(linearRgba.rgb);
+}
+
 // This function take a rgb color (best is to provide color in sRGB space)
 // and return a YCoCg color in [0..1] space for 8bit (An offset is apply in the function)
 // Ref: http://www.nvidia.com/object/real-time-ycocg-dxt-compression.html
     float W = w.x + w.y + w.z + w.w;
     // handle the special case where all the weights are zero.
     return  (W == 0.0) ? a0.y : (w.x * a0.y + w.y* a1.y + w.z* a2.y + w.w * a3.y) / W;
+}
+
+// Hue, Saturation, Value
+// Ranges:
+//  Hue [0.0, 1.0]
+//  Sat [0.0, 1.0]
+//  Lum [0.0, HALF_MAX]
+float3 RgbToHsv(float3 c)
+{
+    const float4 K = float4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
+    float4 p = lerp(float4(c.bg, K.wz), float4(c.gb, K.xy), step(c.b, c.g));
+    float4 q = lerp(float4(p.xyw, c.r), float4(c.r, p.yzx), step(p.x, c.r));
+    float d = q.x - min(q.w, q.y);
+    const float e = 1.0e-4;
+    return float3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
+}
+
+float3 HsvToRgb(float3 c)
+{
+    const float4 K = float4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
+    float3 p = abs(frac(c.xxx + K.xyz) * 6.0 - K.www);
+    return c.z * lerp(K.xxx, saturate(p - K.xxx), c.y);
+}
+
+// SMPTE ST.2084 (PQ) transfer functions
+// 1.0 = 100nits, 100.0 = 10knits
+#define DEFAULT_MAX_PQ 100.0
+
+struct ParamsPQ
+{
+    float N, M;
+    float C1, C2, C3;
+};
+
+static const ParamsPQ PQ =
+{
+    2610.0 / 4096.0 / 4.0,   // N
+    2523.0 / 4096.0 * 128.0, // M
+    3424.0 / 4096.0,         // C1
+    2413.0 / 4096.0 * 32.0,  // C2
+    2392.0 / 4096.0 * 32.0,  // C3
+};
+
+float3 LinearToPQ(float3 x, float maxPQValue)
+{
+    x = PositivePow(x / maxPQValue, PQ.N);
+    float3 nd = (PQ.C1 + PQ.C2 * x) / (1.0 + PQ.C3 * x);
+    return PositivePow(nd, PQ.M);
+}
+
+float3 LinearToPQ(float3 x)
+{
+    return LinearToPQ(x, DEFAULT_MAX_PQ);
+}
+
+float3 PQToLinear(float3 x, float maxPQValue)
+{
+    x = PositivePow(x, rcp(PQ.M));
+    float3 nd = max(x - PQ.C1, 0.0) / (PQ.C2 - (PQ.C3 * x));
+    return PositivePow(nd, rcp(PQ.N)) * maxPQValue;
+}
+
+float3 PQToLinear(float3 x)
+{
+    return PQToLinear(x, DEFAULT_MAX_PQ);
+}
+
+// Alexa LogC converters (El 1000)
+// See http://www.vocas.nl/webfm_send/964
+// Max range is ~58.85666
+
+// Set to 1 to use more precise but more expensive log/linear conversions. I haven't found a proper
+// use case for the high precision version yet so I'm leaving this to 0.
+#define USE_PRECISE_LOGC 0
+
+struct ParamsLogC
+{
+    float cut;
+    float a, b, c, d, e, f;
+};
+
+static const ParamsLogC LogC =
+{
+    0.011361, // cut
+    5.555556, // a
+    0.047996, // b
+    0.244161, // c
+    0.386036, // d
+    5.301883, // e
+    0.092819  // f
+};
+
+float LinearToLogC_Precise(half x)
+{
+    float o;
+    if (x > LogC.cut)
+        o = LogC.c * log10(LogC.a * x + LogC.b) + LogC.d;
+    else
+        o = LogC.e * x + LogC.f;
+    return o;
+}
+
+float3 LinearToLogC(float3 x)
+{
+#if USE_PRECISE_LOGC
+    return float3(
+        LinearToLogC_Precise(x.x),
+        LinearToLogC_Precise(x.y),
+        LinearToLogC_Precise(x.z)
+    );
+#else
+    return LogC.c * log10(LogC.a * x + LogC.b) + LogC.d;
+#endif
+}
+
+float LogCToLinear_Precise(float x)
+{
+    float o;
+    if (x > LogC.e * LogC.cut + LogC.f)
+        o = (pow(10.0, (x - LogC.d) / LogC.c) - LogC.b) / LogC.a;
+    else
+        o = (x - LogC.f) / LogC.e;
+    return o;
+}
+
+float3 LogCToLinear(float3 x)
+{
+#if USE_PRECISE_LOGC
+    return float3(
+        LogCToLinear_Precise(x.x),
+        LogCToLinear_Precise(x.y),
+        LogCToLinear_Precise(x.z)
+    );
+#else
+    return (pow(10.0, (x - LogC.d) / LogC.c) - LogC.b) / LogC.a;
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// Utilities
+//-----------------------------------------------------------------------------
+
+// Fast reversible tonemapper
+// http://gpuopen.com/optimized-reversible-tonemapper-for-resolve/
+float3 FastTonemap(float3 c)
+{
+    return c * rcp(Max3(c.r, c.g, c.b) + 1.0);
+}
+
+float4 FastTonemap(float4 c)
+{
+    return float4(FastTonemap(c.rgb), c.a);
+}
+
+float3 FastTonemap(float3 c, float w)
+{
+    return c * (w * rcp(Max3(c.r, c.g, c.b) + 1.0));
+}
+
+float4 FastTonemap(float4 c, float w)
+{
+    return float4(FastTonemap(c.rgb, w), c.a);
+}
+
+float3 FastTonemapInvert(float3 c)
+{
+    return c * rcp(1.0 - Max3(c.r, c.g, c.b));
+}
+
+float4 FastTonemapInvert(float4 c)
+{
+    return float4(FastTonemapInvert(c.rgb), c.a);
+}
+
+// 3D LUT grading
+// scaleOffset = (1 / lut_size, lut_size - 1)
+float3 ApplyLut3D(TEXTURE3D_ARGS(tex, samplerTex), float3 uvw, float2 scaleOffset)
+{
+    float shift = floor(uvw.z);
+    uvw.xy = uvw.xy * scaleOffset.y * scaleOffset.xx + scaleOffset.xx * 0.5;
+    uvw.x += shift * scaleOffset.x;
+    return SAMPLE_TEXTURE3D(tex, samplerTex, uvw).rgb;
+}
+
+// 2D LUT grading
+// scaleOffset = (1 / lut_width, 1 / lut_height, lut_height - 1)
+float3 ApplyLut2D(TEXTURE2D_ARGS(tex, samplerTex), float3 uvw, float3 scaleOffset)
+{
+    // Strip format where `height = sqrt(width)`
+    uvw.z *= scaleOffset.z;
+    float shift = floor(uvw.z);
+    uvw.xy = uvw.xy * scaleOffset.z * scaleOffset.xy + scaleOffset.xy * 0.5;
+    uvw.x += shift * scaleOffset.y;
+    uvw.xyz = lerp(
+        SAMPLE_TEXTURE2D(tex, samplerTex, uvw.xy).rgb,
+        SAMPLE_TEXTURE2D(tex, samplerTex, uvw.xy + float2(scaleOffset.y, 0.0)).rgb,
+        uvw.z - shift
+    );
+    return uvw;
+}
+
+// Returns the default value for a given position on a 2D strip-format color lookup table
+// params = (lut_height, 0.5 / lut_width, 0.5 / lut_height, lut_height / lut_height - 1)
+float3 GetLutStripValue(float2 uv, float4 params)
+{
+    uv -= params.yz;
+    float3 color;
+    color.r = frac(uv.x * params.x);
+    color.b = uv.x - color.r / params.x;
+    color.g = uv.y;
+    return color * params.w;
 }
 
 #endif // UNITY_COLOR_INCLUDED

ScriptableRenderPipeline/Core/ShaderLibrary/ImageBasedLighting.hlsl

 #include "CommonLighting.hlsl"
 #include "CommonMaterial.hlsl"
 #include "BSDF.hlsl"
-#include "Sampling.hlsl"
+#include "Sampling/Sampling.hlsl"
 
 #ifndef UNITY_SPECCUBE_LOD_STEPS
     #define UNITY_SPECCUBE_LOD_STEPS 6

ScriptableRenderPipeline/Core/Volume/Volume.cs

         public T Add<T>(bool overrides = false)
             where T : VolumeComponent
         {
-            if (Has<T>())
+            return (T)Add(typeof(T), overrides);
+        }
+
+        public VolumeComponent Add(Type type, bool overrides = false)
+        {
+            if (Has(type))
-            var component = ScriptableObject.CreateInstance<T>();
+            var component = (VolumeComponent)ScriptableObject.CreateInstance(type);
             component.SetAllOverridesTo(overrides);
             components.Add(component);
             isDirty = true;
         public void Remove<T>()
             where T : VolumeComponent
         {
+            Remove(typeof(T));
+        }
+
+        public void Remove(Type type)
+        {
-            var type = typeof(T);
 
             for (int i = 0; i < components.Count; i++)
             {
         public bool Has<T>()
             where T : VolumeComponent
         {
-            var type = typeof(T);
+            return Has(typeof(T));
+        }
+        public bool Has(Type type)
+        {
             foreach (var component in components)
             {
                 if (component.GetType() == type)
             var scale = transform.localScale;
             var invScale = new Vector3(1f / scale.x, 1f / scale.y, 1f / scale.z);
             Gizmos.matrix = Matrix4x4.TRS(transform.position, transform.rotation, scale);
-            Gizmos.color = new Color(0f, 1f, 0.1f, 0.6f);
+            Gizmos.color = new Color(0f, 1f, 0.1f, 0.35f);
 
             // Draw a separate gizmo for each collider
             foreach (var collider in colliders)

ScriptableRenderPipeline/Core/Volume/VolumeComponent.cs

 
 namespace UnityEngine.Experimental.Rendering
 {
+    [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
+    public sealed class VolumeComponentMenu : Attribute
+    {
+        public readonly string menu;
+        // TODO: Add support for component icons
+
+        public VolumeComponentMenu(string menu)
+        {
+            this.menu = menu;
+        }
+    }
+
     [Serializable]
     public class VolumeComponent : ScriptableObject
     {
 
         internal ReadOnlyCollection<VolumeParameter> parameters { get; private set; }
 
-        void OnEnable()
+        protected virtual void OnEnable()
         {
             // Automatically grab all fields of type VolumeParameter for this instance
             parameters = this.GetType()
                 .Select(t => (VolumeParameter)t.GetValue(this))
                 .ToList()
                 .AsReadOnly();
+        }
+
+        protected virtual void OnDisable()
+        {
         }
 
         public void SetAllOverridesTo(bool state)

ScriptableRenderPipeline/Core/Volume/VolumeManager.cs

         }
         //<<<
 
+        // Internal stack
+        public VolumeStack stack { get; private set; }
+
+        // Current list of tracked component types
+        public IEnumerable<Type> baseComponentTypes { get; private set; }
+
         // Max amount of layers available in Unity
         const int k_MaxLayerCount = 32;
 
         // Keep track of sorting states for layer masks
         readonly Dictionary<LayerMask, bool> m_SortNeeded;
 
-        // Internal state of all component types
-        readonly Dictionary<Type, VolumeComponent> m_Components;
-
         // Internal list of default state for each component type - this is used to reset component
         // states on update instead of having to implement a Reset method on all components (which
         // would be error-prone)
         readonly List<Collider> m_TempColliders;
 
-        // In the editor, when entering play-mode, it will call the constructor and OnEditorReload()
-        // which in turn will call ReloadBaseTypes() twice, so we need to keep track of the reloads
-        // to avoid wasting any more CPU than required
-        static bool s_StopReloads = false;
-
         VolumeManager()
         {
             m_SortedVolumes = new Dictionary<LayerMask, List<Volume>>();
-            m_Components = new Dictionary<Type, VolumeComponent>();
-        }
-#if UNITY_EDITOR
-        // Called every time Unity recompiles scripts in the editor. We need this to keep track of
-        // any new custom component the user might add to the project.
-        [UnityEditor.Callbacks.DidReloadScripts]
-        static void OnEditorReload()
-        {
-            if (!s_StopReloads)
-                instance.ReloadBaseTypes();
-
-            s_StopReloads = false;
+            stack = CreateStack();
-#endif
-            // Clean component map & default states
-            foreach (var component in m_Components)
-                CoreUtils.Destroy(component.Value);
-
-            foreach (var component in m_ComponentsDefaultState)
-                CoreUtils.Destroy(component);
-
-            m_Components.Clear();
-            m_ComponentsDefaultState.Clear();
-
-            // Rebuild it from scratch
-            var types = CoreUtils.GetAllAssemblyTypes()
+            // Grab all the component types we can find
+            baseComponentTypes = CoreUtils.GetAllAssemblyTypes()
-            foreach (var type in types)
+            // Keep an instance of each type to be used in a virtual lowest priority global volume
+            // so that we have a default state to fallback to when exiting volumes
+            foreach (var type in baseComponentTypes)
-                // We need two instances, one for global state tracking and another one to keep a
-                // default state that will act as the lowest priority global volume (so that we have
-                // a state to fallback to when exiting volumes)
-                m_Components.Add(type, inst);
-
-                inst = (VolumeComponent)ScriptableObject.CreateInstance(type);
-
-            s_StopReloads = true;
-        public T GetComponent<T>()
-            where T : VolumeComponent
-        {
-            var comp = GetComponent(typeof(T));
-            return (T)comp;
-        }
-
-        public VolumeComponent GetComponent(Type type)
+        public VolumeStack CreateStack()
-            VolumeComponent comp;
-            m_Components.TryGetValue(type, out comp);
-            return comp;
+            return new VolumeStack(baseComponentTypes);
         }
 
         public void Register(Volume volume, int layer)
             // Look for existing cached layer masks and add it there if needed
             foreach (var kvp in m_SortedVolumes)
             {
-                var mask = kvp.Key;
-
-                if ((mask & (1 << layer)) != 0)
+                if ((kvp.Key & (1 << layer)) != 0)
                     kvp.Value.Add(volume);
             }
 
 
             foreach (var kvp in m_SortedVolumes)
             {
-                var mask = kvp.Key;
-
-                if ((mask & (1 << layer)) == 0)
+                if ((kvp.Key & (1 << layer)) == 0)
                     continue;
 
                 kvp.Value.Remove(volume);
+        public bool IsComponentActiveInMask<T>(LayerMask layerMask)
+            where T : VolumeComponent
+        {
+            int mask = layerMask.value;
+
+            foreach (var kvp in m_SortedVolumes)
+            {
+                if ((kvp.Key & mask) == 0)
+                    continue;
+
+                foreach (var volume in kvp.Value)
+                {
+                    T component;
+                    if (volume.TryGet(out component) && component.active)
+                        return true;
+                }
+            }
+
+            return false;
+        }
+
         internal void SetLayerDirty(int layer)
         {
             Assert.IsTrue(layer >= 0 && layer <= k_MaxLayerCount, "Invalid layer bit");
         }
 
         // Go through all listed components and lerp overriden values in the global state
-        void OverrideData(List<VolumeComponent> components, float interpFactor)
+        void OverrideData(VolumeStack stack, List<VolumeComponent> components, float interpFactor)
         {
             foreach (var component in components)
             {
-                var target = GetComponent(component.GetType());
+                var target = stack.GetComponent(component.GetType());
                 int count = component.parameters.Count;
 
                 for (int i = 0; i < count; i++)
         }
 
         // Faster version of OverrideData to force replace values in the global state
-        void ReplaceData(List<VolumeComponent> components)
+        void ReplaceData(VolumeStack stack, List<VolumeComponent> components)
-                var target = GetComponent(component.GetType());
+                var target = stack.GetComponent(component.GetType());
                 int count = component.parameters.Count;
 
                 for (int i = 0; i < count; i++)
         // in the update loop before rendering
         public void Update(Transform trigger, LayerMask layerMask)
         {
+            Update(stack, trigger, layerMask);
+        }
+
+        // Update a specific stack - can be used to manage your own stack and store it for later use
+        public void Update(VolumeStack stack, Transform trigger, LayerMask layerMask)
+        {
-            ReplaceData(m_ComponentsDefaultState);
+            ReplaceData(stack, m_ComponentsDefaultState);
 
             bool onlyGlobal = trigger == null;
             var triggerPos = onlyGlobal ? Vector3.zero : trigger.position;
                 // Global volumes always have influence
                 if (volume.isGlobal)
                 {
-                    OverrideData(volume.components, Mathf.Clamp01(volume.weight));
+                    OverrideData(stack, volume.components, Mathf.Clamp01(volume.weight));
                     continue;
                 }
 
                     interpFactor = 1f - (closestDistanceSqr / blendDistSqr);
 
                 // No need to clamp01 the interpolation factor as it'll always be in [0;1[ range
-                OverrideData(volume.components, interpFactor * Mathf.Clamp01(volume.weight));
+                OverrideData(stack, volume.components, interpFactor * Mathf.Clamp01(volume.weight));
             }
         }
 

ScriptableRenderPipeline/Core/Volume/VolumeParameter.cs

 using System;
+using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Diagnostics;
 using System.Linq;
     }
 
     [Serializable, DebuggerDisplay(k_DebuggerDisplay)]
-    public class VolumeParameter<T> : VolumeParameter
+    public class VolumeParameter<T> : VolumeParameter, IEquatable<VolumeParameter<T>>
     {
         [SerializeField]
         protected T m_Value;
 
         public static bool operator ==(VolumeParameter<T> lhs, T rhs)
         {
-            return lhs.value != null && lhs.value.Equals(rhs);
+            return lhs != null && lhs.value != null && lhs.value.Equals(rhs);
+        }
+
+        public bool Equals(VolumeParameter<T> other)
+        {
+            if (ReferenceEquals(null, other))
+                return false;
+
+            if (ReferenceEquals(this, other))
+                return true;
+
+            return EqualityComparer<T>.Default.Equals(m_Value, other.m_Value);
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj))
+                return false;
+
+            if (ReferenceEquals(this, obj))
+                return true;
+
+            if (obj.GetType() != GetType())
+                return false;
+
+            return Equals((VolumeParameter<T>)obj);
         }
 
         //

ScriptableRenderPipeline/Core/package.json

 {
     "name": "com.unity.render-pipelines.core",
     "description": "Core library for Unity render pipelines.",
-    "version": "0.1.20",
+    "version": "0.1.21",
     "unity": "2018.1",
     "dependencies": {
         "com.unity.postprocessing": "0.1.7"

ScriptableRenderPipeline/HDRenderPipeline/Editor/HDAssetFactory.cs

                 newAsset.debugFullScreenShader = Load<Shader>(HDRenderPipelinePath + "Debug/DebugFullScreen.Shader");
 
                 newAsset.deferredShader = Load<Shader>(HDRenderPipelinePath + "Lighting/Deferred.Shader");
-                newAsset.subsurfaceScatteringCS = Load<ComputeShader>(HDRenderPipelinePath + "Material/Lit/Resources/SubsurfaceScattering.compute");
                 newAsset.gaussianPyramidCS = Load<ComputeShader>(PostProcessingPath + "Shaders/Builtins/GaussianDownsample.compute");
                 newAsset.depthPyramidCS = Load<ComputeShader>(HDRenderPipelinePath + "RenderPipelineResources/DepthDownsample.compute");
                 newAsset.copyChannelCS = Load<ComputeShader>(CorePath + "Resources/GPUCopy.compute");
 
                 newAsset.deferredDirectionalShadowComputeShader = Load<ComputeShader>(HDRenderPipelinePath + "Lighting/DeferredDirectionalShadow.compute");
 
-                // SceneSettings
+                // SubsurfaceScattering
+                newAsset.subsurfaceScatteringCS = Load<ComputeShader>(HDRenderPipelinePath + "Material/SubsurfaceScattering/SubsurfaceScattering.compute");
+                newAsset.subsurfaceScattering = Load<Shader>(HDRenderPipelinePath + "Material/SubsurfaceScattering/SubsurfaceScattering.shader");
+                newAsset.combineLighting = Load<Shader>(HDRenderPipelinePath + "Material/SubsurfaceScattering/CombineLighting.shader");
+
+                // General
+                newAsset.copyStencilBuffer = Load<Shader>(HDRenderPipelinePath + "RenderPipelineResources/copyStencilBuffer.shader");
 
                 // Sky
                 newAsset.blitCubemap = Load<Shader>(HDRenderPipelinePath + "Sky/BlitCubemap.shader");

ScriptableRenderPipeline/HDRenderPipeline/Editor/Lighting/HDLightEditor.cs

         {
             m_LightShape = (LightShape)EditorGUILayout.Popup(s_Styles.shape, (int)m_LightShape, s_Styles.shapeNames);
 
+            if (m_LightShape != LightShape.Directional)
+                settings.DrawRange(false);
+
             // LightShape is HD specific, it need to drive LightType from the original LightType
             // when it make sense, so the GI is still in sync with the light shape
             switch (m_LightShape)
             settings.DrawColor();
             settings.DrawIntensity();
             settings.DrawBounceIntensity();
-            settings.DrawRange(false);
             settings.DrawLightmapping();
 
             // No cookie with area light (maybe in future textured area light ?)

ScriptableRenderPipeline/HDRenderPipeline/Editor/Material/Lit/BaseLitUI.cs

         static public void SetupBaseLitMaterialPass(Material material)
         {
             SetupBaseUnlitMaterialPass(material);
+
+            bool windEnabled = material.GetFloat(kWindEnabled) > 0.0f;
+            bool enableVertexDisplacement = (DisplacementMode)material.GetFloat(kDisplacementMode) == DisplacementMode.Vertex;
+            
+            material.SetShaderPassEnabled(HDShaderPassNames.s_MotionVectorsStr, windEnabled || enableVertexDisplacement);
+
         }
     }
 } // namespace UnityEditor

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

             public readonly GUIContent   profileMinMaxThickness = new GUIContent("Min-Max Thickness (mm)", "Shows the values of the thickness remap below (in millimeters).");
             public readonly GUIContent   profileThicknessRemap  = new GUIContent("Thickness Remap (mm)", "Remaps the thickness parameter from [0, 1] to the desired range (in millimeters).");
             public readonly GUIContent   profileWorldScale      = new GUIContent("World Scale", "Size of the world unit in meters.");
-            // Old SSS Model >>>
+            public readonly GUIContent   profileFresnel0        = new GUIContent("Specular", "Fraction of light reflected at the normal angle of incidence. Typical skin value is 0.028");
+            // Jimenez SSS Model
-            // <<< Old SSS Model
+            // End Jimenez SSS Model
             public readonly GUIStyle     centeredMiniBoldLabel     = new GUIStyle(GUI.skin.label);
 
             public Styles()

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

             internal SerializedProperty transmissionMode;
             internal SerializedProperty thicknessRemap;
             internal SerializedProperty worldScale;
+            internal SerializedProperty fresnel0;
 
             // Old SSS Model >>>
             internal SerializedProperty scatterDistance1;
                     transmissionMode = rp.Find(x => x.transmissionMode),
                     thicknessRemap = rp.Find(x => x.thicknessRemap),
                     worldScale = rp.Find(x => x.worldScale),
+                    fresnel0 = rp.Find(x => x.fresnel0),
 
                     scatterDistance1 = rp.Find(x => x.scatterDistance1),
                     scatterDistance2 = rp.Find(x => x.scatterDistance2),
 
             serializedObject.Update();
 
-            using (var scope = new EditorGUI.ChangeCheckScope())
-            {
-                EditorGUILayout.PropertyField(m_UseDisneySSS, s_Styles.useDisneySSS);
-
-                if (scope.changed && m_HDPipeline != null)
-                    m_HDPipeline.CreateSssMaterials();
-            }
+            EditorGUILayout.PropertyField(m_UseDisneySSS, s_Styles.useDisneySSS);
 
             EditorGUILayout.Space();
 
                         EditorGUILayout.MinMaxSlider(s_Styles.profileThicknessRemap, ref thicknessRemap.x, ref thicknessRemap.y, 0f, 50f);
                         profile.thicknessRemap.vector2Value = thicknessRemap;
                         EditorGUILayout.PropertyField(profile.worldScale, s_Styles.profileWorldScale);
+                        EditorGUILayout.Slider(profile.fresnel0, 0.0f, 0.1f, s_Styles.profileFresnel0);
 
                         EditorGUILayout.Space();
                         EditorGUILayout.LabelField(s_Styles.profilePreview0, s_Styles.centeredMiniBoldLabel);

ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipeline.cs

         RenderTargetIdentifier[] m_RTIDs = new RenderTargetIdentifier[k_MaxDbuffer];
 
         public void InitDBuffers(int width, int height,  CommandBuffer cmd)
-        {            
+        {
             dbufferCount = Decal.GetMaterialDBufferCount();
             RenderTextureFormat[] rtFormat;
             RenderTextureReadWrite[] rtReadWrite;
 
         // Renderer Bake configuration can vary depends on if shadow mask is enabled or no
         RendererConfiguration m_currentRendererConfigurationBakedLighting = HDUtils.k_RendererConfigurationBakedLighting;
-        Material m_CopyStencilForSplitLighting;
-        // Various set of material use in render loop
-        ComputeShader m_SubsurfaceScatteringCS { get { return m_Asset.renderPipelineResources.subsurfaceScatteringCS; } }
-        int m_SubsurfaceScatteringKernel;
-        Material m_CombineLightingPass;
-        // Old SSS Model >>>
-        Material m_SssVerticalFilterPass;
-        Material m_SssHorizontalFilterAndCombinePass;
-        // <<< Old SSS Model
-
         ComputeShader m_GaussianPyramidCS { get { return m_Asset.renderPipelineResources.gaussianPyramidCS; } }
         int m_GaussianPyramidKernel;
         ComputeShader m_DepthPyramidCS { get { return m_Asset.renderPipelineResources.depthPyramidCS; } }
         // Various buffer
         readonly int m_CameraColorBuffer;
         readonly int m_CameraSssDiffuseLightingBuffer;
-        // Old SSS Model >>>
-        readonly int m_CameraFilteringBuffer;
-        // <<< Old SSS Model
         readonly int m_ShadowMaskBuffer;
         readonly int m_VelocityBuffer;
         readonly int m_DistortionBuffer;
         // 'm_CameraColorBuffer' does not contain diffuse lighting of SSS materials until the SSS pass. It is stored within 'm_CameraSssDiffuseLightingBuffer'.
         readonly RenderTargetIdentifier m_CameraColorBufferRT;
         readonly RenderTargetIdentifier m_CameraSssDiffuseLightingBufferRT;
-        // Old SSS Model >>>
-        readonly RenderTargetIdentifier m_CameraFilteringBufferRT;
-        // <<< Old SSS Model
         readonly RenderTargetIdentifier m_VelocityBufferRT;
         readonly RenderTargetIdentifier m_DistortionBufferRT;
         readonly RenderTargetIdentifier m_GaussianPyramidColorBufferRT;
         RenderTexture m_CameraDepthStencilBuffer;
         RenderTexture m_CameraDepthBufferCopy;
         RenderTexture m_CameraStencilBufferCopy;
-        RenderTexture m_HTile;                   // If the hardware does not expose it, we compute our own, optimized to only contain the SSS bit
-        RenderTargetIdentifier m_HTileRT;
 
         static CustomSampler[] m_samplers = new CustomSampler[(int)CustomSamplerId.Max];
 
             m_CameraColorBufferRT              = new RenderTargetIdentifier(m_CameraColorBuffer);
             m_CameraSssDiffuseLightingBuffer   = HDShaderIDs._CameraSssDiffuseLightingBuffer;
             m_CameraSssDiffuseLightingBufferRT = new RenderTargetIdentifier(m_CameraSssDiffuseLightingBuffer);
-            m_CameraFilteringBuffer            = HDShaderIDs._CameraFilteringBuffer;
-            m_CameraFilteringBufferRT          = new RenderTargetIdentifier(m_CameraFilteringBuffer);
-            CreateSssMaterials();
+            m_SSSBufferManager.Build(asset.renderPipelineResources, asset.sssSettings);
-            m_CopyStencilForSplitLighting   = CoreUtils.CreateEngineMaterial("Hidden/HDRenderPipeline/CopyStencilBuffer");
-            m_CopyStencilForSplitLighting.SetInt(HDShaderIDs._StencilRef, (int)StencilLightingUsage.SplitLighting);
-            m_CopyStencilForNoLighting = CoreUtils.CreateEngineMaterial("Hidden/HDRenderPipeline/CopyStencilBuffer");
+            // General material
+            m_CopyStencilForNoLighting = CoreUtils.CreateEngineMaterial(asset.renderPipelineResources.copyStencilBuffer);
-            m_CameraMotionVectorsMaterial   = CoreUtils.CreateEngineMaterial("Hidden/HDRenderPipeline/CameraMotionVectors");
+            m_CameraMotionVectorsMaterial = CoreUtils.CreateEngineMaterial(asset.renderPipelineResources.cameraMotionVectors);
 
             InitializeDebugMaterials();
 
             m_ErrorMaterial = CoreUtils.CreateEngineMaterial("Hidden/InternalErrorShader");
         }
 
-        public void CreateSssMaterials()
-        {
-            m_SubsurfaceScatteringKernel = m_SubsurfaceScatteringCS.FindKernel("SubsurfaceScattering");
-
-            CoreUtils.Destroy(m_CombineLightingPass);
-            m_CombineLightingPass = CoreUtils.CreateEngineMaterial("Hidden/HDRenderPipeline/CombineLighting");
-
-            // Old SSS Model >>>
-            CoreUtils.Destroy(m_SssVerticalFilterPass);
-            m_SssVerticalFilterPass = CoreUtils.CreateEngineMaterial("Hidden/HDRenderPipeline/SubsurfaceScattering");
-            m_SssVerticalFilterPass.DisableKeyword("SSS_FILTER_HORIZONTAL_AND_COMBINE");
-            m_SssVerticalFilterPass.SetFloat(HDShaderIDs._DstBlend, (float)BlendMode.Zero);
-
-            CoreUtils.Destroy(m_SssHorizontalFilterAndCombinePass);
-            m_SssHorizontalFilterAndCombinePass = CoreUtils.CreateEngineMaterial("Hidden/HDRenderPipeline/SubsurfaceScattering");
-            m_SssHorizontalFilterAndCombinePass.EnableKeyword("SSS_FILTER_HORIZONTAL_AND_COMBINE");
-            m_SssHorizontalFilterAndCombinePass.SetFloat(HDShaderIDs._DstBlend, (float)BlendMode.One);
-            // <<< Old SSS Model
-        }
-
         void InitializeRenderStateBlocks()
         {
             m_DepthStateOpaque = new RenderStateBlock
 
             m_MaterialList.ForEach(material => material.Cleanup());
 
+            CoreUtils.Destroy(m_CopyStencilForNoLighting);
+            CoreUtils.Destroy(m_CameraMotionVectorsMaterial);
+
             CoreUtils.Destroy(m_DebugViewMaterialGBuffer);
             CoreUtils.Destroy(m_DebugViewMaterialGBufferShadowMask);
             CoreUtils.Destroy(m_DebugDisplayLatlong);
 
+            m_SSSBufferManager.Cleanup();
             m_SkyManager.Cleanup();
 
 #if UNITY_EDITOR
                 m_CameraStencilBufferCopy.Create();
                 m_CameraStencilBufferCopyRT = new RenderTargetIdentifier(m_CameraStencilBufferCopy);
             }
-
-            if (NeedHTileCopy())
-            {
-                if (m_HTile!= null)
-                    m_HTile.Release();
-
-                // We use 8x8 tiles in order to match the native GCN HTile as closely as possible.
-                m_HTile = new RenderTexture((camera.pixelWidth + 7) / 8, (camera.pixelHeight + 7) / 8, 0, RenderTextureFormat.R8, RenderTextureReadWrite.Linear); // DXGI_FORMAT_R8_UINT is not supported by Unity
-                m_HTile.filterMode = FilterMode.Point;
-                m_HTile.enableRandomWrite = true;
-                m_HTile.Create();
-                m_HTileRT = new RenderTargetIdentifier(m_HTile);
-            }
-
         }
 
         void Resize(Camera camera)
             bool resolutionChanged = camera.pixelWidth != m_CurrentWidth || camera.pixelHeight != m_CurrentHeight;
 
             if (resolutionChanged || m_CameraDepthStencilBuffer == null)
+            {
+                m_SSSBufferManager.Resize(camera);
+            }
 
             if (resolutionChanged || m_LightLoop.NeedResize())
             {
                     cmd.SetGlobalInt(HDShaderIDs._EnvLightSkyEnabled, 0);
                 }
 
-                // Broadcast SSS parameters to all shaders.
-                cmd.SetGlobalInt(HDShaderIDs._EnableSSSAndTransmission, m_CurrentDebugDisplaySettings.renderingDebugSettings.enableSSSAndTransmission ? 1 : 0);
-                cmd.SetGlobalInt(HDShaderIDs._UseDisneySSS, sssParameters.useDisneySSS ? 1 : 0);
-                unsafe
-                {
-                    // Warning: Unity is not able to losslessly transfer integers larger than 2^24 to the shader system.
-                    // Therefore, we bitcast uint to float in C#, and bitcast back to uint in the shader.
-                    uint texturingModeFlags = sssParameters.texturingModeFlags;
-                    uint transmissionFlags  = sssParameters.transmissionFlags;
-                    cmd.SetGlobalFloat(HDShaderIDs._TexturingModeFlags, *(float*)&texturingModeFlags);
-                    cmd.SetGlobalFloat(HDShaderIDs._TransmissionFlags,  *(float*)&transmissionFlags);
-                }
-                cmd.SetGlobalVectorArray(HDShaderIDs._ThicknessRemaps,            sssParameters.thicknessRemaps);
-                cmd.SetGlobalVectorArray(HDShaderIDs._ShapeParams,                sssParameters.shapeParams);
-                cmd.SetGlobalVectorArray(HDShaderIDs._HalfRcpVariancesAndWeights, sssParameters.halfRcpVariancesAndWeights);
-                cmd.SetGlobalVectorArray(HDShaderIDs._TransmissionTints,          sssParameters.transmissionTints);
-                cmd.SetGlobalVectorArray(HDShaderIDs._WorldScales,                sssParameters.worldScales);
+                m_SSSBufferManager.PushGlobalParams(cmd, sssParameters, m_CurrentDebugDisplaySettings);
             }
         }
 
             // TODO: test/implement for other platforms.
-            return SystemInfo.graphicsDeviceType != GraphicsDeviceType.PlayStation4;
+            return  SystemInfo.graphicsDeviceType != GraphicsDeviceType.PlayStation4 &&
+                    SystemInfo.graphicsDeviceType != GraphicsDeviceType.XboxOne &&
+                    SystemInfo.graphicsDeviceType != GraphicsDeviceType.XboxOneD3D12;
         }
 
         bool NeedStencilBufferCopy()
-            return m_CurrentDebugDisplaySettings.renderingDebugSettings.enableSSSAndTransmission || m_LightLoop.GetFeatureVariantsEnabled();
-        }
-
-        bool NeedHTileCopy()
-        {
-            // Currently, Unity does not offer a way to access the GCN HTile even on PS4 and Xbox One.
-            // Therefore, it's computed in a pixel shader, and optimized to only contain the SSS bit.
-            return m_CurrentDebugDisplaySettings.renderingDebugSettings.enableSSSAndTransmission && sssSettings.useDisneySSS;
-        }
-
-        bool NeedTemporarySubsurfaceBuffer()
-        {
-            // Typed UAV loads from FORMAT_R16G16B16A16_FLOAT is an optional feature of Direct3D 11.
-            // Most modern GPUs support it. We can avoid performing a costly copy in this case.
-            // TODO: test/implement for other platforms.
-            return m_CurrentDebugDisplaySettings.renderingDebugSettings.enableSSSAndTransmission && (!sssSettings.useDisneySSS || (
-            SystemInfo.graphicsDeviceType != GraphicsDeviceType.PlayStation4 &&
-            SystemInfo.graphicsDeviceType != GraphicsDeviceType.XboxOne &&
-            SystemInfo.graphicsDeviceType != GraphicsDeviceType.XboxOneD3D12));
+            return m_LightLoop.GetFeatureVariantsEnabled();
         }
 
         RenderTargetIdentifier GetDepthTexture()
 
-        RenderTargetIdentifier GetHTile()
-        {
-            // Currently, Unity does not offer a way to access the GCN HTile.
-            return m_HTileRT;
-        }
-
         void CopyDepthBufferIfNeeded(CommandBuffer cmd)
         {
             using (new ProfilingSample(cmd, NeedDepthBufferCopy() ? "Copy DepthBuffer" : "Set DepthBuffer", GetSampler(CustomSamplerId.CopySetDepthBuffer)))
                         cmd.CopyTexture(m_CameraDepthStencilBufferRT, m_CameraDepthBufferCopyRT);
                     }
                 }
-
-                cmd.SetGlobalTexture(HDShaderIDs._MainDepthTexture, GetDepthTexture());
             }
         }
 
                     // In both forward and deferred, everything opaque should have been rendered at this point so we can safely copy the depth buffer for later processing.
                     CopyDepthBufferIfNeeded(cmd);
 
+                    // Depth texture is now ready, bind it.
+                    cmd.SetGlobalTexture(HDShaderIDs._MainDepthTexture, GetDepthTexture());
+
                     RenderPyramidDepth(camera, cmd, renderContext, FullScreenDebugMode.DepthPyramid);
 
                     if (m_CurrentDebugDisplaySettings.IsDebugMaterialDisplayEnabled())
                             {
                                 CoreUtils.SetRenderTarget(cmd, m_CameraStencilBufferCopyRT, ClearFlag.Color, CoreUtils.clearColorAllBlack);
 
-                                cmd.SetRandomWriteTarget(1, GetHTile());
                                 // In the material classification shader we will simply test is we are no lighting
                                 // Use ShaderPassID 1 => "Pass 1 - Write 1 if value different from stencilRef to output"
                                 CoreUtils.DrawFullScreen(cmd, m_CopyStencilForNoLighting, m_CameraStencilBufferCopyRT, m_CameraDepthStencilBufferRT, null, 1);
                         RenderForwardError(m_CullResults, camera, renderContext, cmd, ForwardPass.Opaque);
 
                         // SSS pass here handle both SSS material from deferred and forward
-                        SubsurfaceScatteringPass(hdCamera, cmd, sssSettings);
+                        m_SSSBufferManager.SubsurfaceScatteringPass(hdCamera, cmd, sssSettings, m_CurrentDebugDisplaySettings,
+                                                                    m_CameraColorBufferRT, m_CameraSssDiffuseLightingBufferRT, m_CameraDepthStencilBufferRT, GetDepthTexture());
 
                         RenderSky(hdCamera, cmd);
 
 
             // Render transparent depth prepass after opaque one
             using (new ProfilingSample(cmd, "Transparent Depth Prepass", GetSampler(CustomSamplerId.TransparentDepthPrepass)))
-            {                
+            {
                 RenderTransparentRenderList(cull, camera, renderContext, cmd, m_TransparentDepthPrePassNames);
             }
         }
 
             using (new ProfilingSample(cmd, "DBuffer", GetSampler(CustomSamplerId.DBuffer)))
             {
+                // We need to copy depth buffer texture if we want to bind it at this stage
+                CopyDepthBufferIfNeeded(cmd);
+
+                // Depth texture is now ready, bind it.
+                cmd.SetGlobalTexture(HDShaderIDs._MainDepthTexture, GetDepthTexture());
+
-                cmd.SetGlobalTexture(HDShaderIDs._MainDepthTexture, GetDepthTexture());
 				DecalSystem.instance.Render(renderContext, cameraPos, cmd);
             }
         }
             options.outputSplitLighting = false;
 
             m_LightLoop.RenderDeferredLighting(hdCamera, cmd, m_CurrentDebugDisplaySettings, m_MRTCache2, m_CameraDepthStencilBufferRT, depthTexture, options);
-        }
-
-        // Combines specular lighting and diffuse lighting with subsurface scattering.
-        void SubsurfaceScatteringPass(HDCamera hdCamera, CommandBuffer cmd, SubsurfaceScatteringSettings sssParameters)
-        {
-            if (!m_CurrentDebugDisplaySettings.renderingDebugSettings.enableSSSAndTransmission)
-                return;
-
-            using (new ProfilingSample(cmd, "Subsurface Scattering", GetSampler(CustomSamplerId.SubsurfaceScattering)))
-            {
-                if (sssSettings.useDisneySSS)
-                {
-                    using (new ProfilingSample(cmd, "HTile for SSS", GetSampler(CustomSamplerId.HTileForSSS)))
-                    {
-                        CoreUtils.SetRenderTarget(cmd, m_HTileRT, ClearFlag.Color, CoreUtils.clearColorAllBlack);
-
-                        cmd.SetRandomWriteTarget(1, GetHTile());
-                        // Generate HTile for the split lighting stencil usage. Don't write into stencil texture (shaderPassId = 2)
-                        // Use ShaderPassID 1 => "Pass 2 - Export HTILE for stencilRef to output"
-                        CoreUtils.DrawFullScreen(cmd, m_CopyStencilForSplitLighting, m_CameraStencilBufferCopyRT, m_CameraDepthStencilBufferRT, null, 2);
-                        cmd.ClearRandomWriteTargets();
-                    }
-
-                    // TODO: Remove this once fix, see comment inside the function
-                    hdCamera.SetupComputeShader(m_SubsurfaceScatteringCS, cmd);
-
-                    unsafe
-                    {
-                        // Warning: Unity is not able to losslessly transfer integers larger than 2^24 to the shader system.
-                        // Therefore, we bitcast uint to float in C#, and bitcast back to uint in the shader.
-                        uint texturingModeFlags = sssParameters.texturingModeFlags;
-                        cmd.SetComputeFloatParam(m_SubsurfaceScatteringCS, HDShaderIDs._TexturingModeFlags, *(float*)&texturingModeFlags);
-                    }
-
-                    cmd.SetComputeVectorArrayParam(m_SubsurfaceScatteringCS, HDShaderIDs._WorldScales,        sssParameters.worldScales);
-                    cmd.SetComputeVectorArrayParam(m_SubsurfaceScatteringCS, HDShaderIDs._FilterKernels,      sssParameters.filterKernels);
-                    cmd.SetComputeVectorArrayParam(m_SubsurfaceScatteringCS, HDShaderIDs._ShapeParams,        sssParameters.shapeParams);
-
-                    cmd.SetComputeTextureParam(m_SubsurfaceScatteringCS, m_SubsurfaceScatteringKernel, HDShaderIDs._DepthTexture,     GetDepthTexture());
-                    cmd.SetComputeTextureParam(m_SubsurfaceScatteringCS, m_SubsurfaceScatteringKernel, HDShaderIDs._HTile,            GetHTile());
-                    cmd.SetComputeTextureParam(m_SubsurfaceScatteringCS, m_SubsurfaceScatteringKernel, HDShaderIDs._IrradianceSource, m_CameraSssDiffuseLightingBufferRT);
-
-                    for (int i = 0; i < m_SSSBufferManager.sssBufferCount; ++i)
-                    {
-                        cmd.SetComputeTextureParam(m_SubsurfaceScatteringCS, m_SubsurfaceScatteringKernel, HDShaderIDs._SSSBufferTexture[i], m_SSSBufferManager.GetSSSBuffers(i));
-                    }
-
-                    if (NeedTemporarySubsurfaceBuffer())
-                    {
-                        cmd.SetComputeTextureParam(m_SubsurfaceScatteringCS, m_SubsurfaceScatteringKernel, HDShaderIDs._CameraFilteringBuffer, m_CameraFilteringBufferRT);
-
-                        // Perform the SSS filtering pass which fills 'm_CameraFilteringBufferRT'.
-                        // We dispatch 4x swizzled 16x16 groups per a 32x32 macrotile.
-                        cmd.DispatchCompute(m_SubsurfaceScatteringCS, m_SubsurfaceScatteringKernel, 4, ((int)hdCamera.screenSize.x + 31) / 32, ((int)hdCamera.screenSize.y + 31) / 32);
-
-                        cmd.SetGlobalTexture(HDShaderIDs._IrradianceSource, m_CameraFilteringBufferRT);  // Cannot set a RT on a material
-
-                        // Additively blend diffuse and specular lighting into 'm_CameraColorBufferRT'.
-                        CoreUtils.DrawFullScreen(cmd, m_CombineLightingPass, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT);
-                    }
-                    else
-                    {
-                        cmd.SetComputeTextureParam(m_SubsurfaceScatteringCS, m_SubsurfaceScatteringKernel, HDShaderIDs._CameraColorTexture, m_CameraColorBufferRT);
-
-                        // Perform the SSS filtering pass which performs an in-place update of 'm_CameraColorBufferRT'.
-                        // We dispatch 4x swizzled 16x16 groups per a 32x32 macrotile.
-                        cmd.DispatchCompute(m_SubsurfaceScatteringCS, m_SubsurfaceScatteringKernel, 4, ((int)hdCamera.screenSize.x + 31) / 32, ((int)hdCamera.screenSize.y + 31) / 32);
-                    }
-                }
-                else
-                {
-                    for (int i = 0; i < m_SSSBufferManager.sssBufferCount; ++i)
-                    {
-                        cmd.SetGlobalTexture(HDShaderIDs._SSSBufferTexture[i], m_SSSBufferManager.GetSSSBuffers(i));
-                    }
-
-                    cmd.SetGlobalTexture(HDShaderIDs._IrradianceSource, m_CameraSssDiffuseLightingBufferRT);  // Cannot set a RT on a material
-                    m_SssVerticalFilterPass.SetVectorArray(HDShaderIDs._FilterKernelsBasic,       sssParameters.filterKernelsBasic);
-                    m_SssVerticalFilterPass.SetVectorArray(HDShaderIDs._HalfRcpWeightedVariances, sssParameters.halfRcpWeightedVariances);
-                    // Perform the vertical SSS filtering pass which fills 'm_CameraFilteringBufferRT'.
-                    CoreUtils.DrawFullScreen(cmd, m_SssVerticalFilterPass, m_CameraFilteringBufferRT, m_CameraDepthStencilBufferRT);
-
-                    cmd.SetGlobalTexture(HDShaderIDs._IrradianceSource, m_CameraFilteringBufferRT);  // Cannot set a RT on a material
-                    m_SssHorizontalFilterAndCombinePass.SetVectorArray(HDShaderIDs._FilterKernelsBasic,       sssParameters.filterKernelsBasic);
-                    m_SssHorizontalFilterAndCombinePass.SetVectorArray(HDShaderIDs._HalfRcpWeightedVariances, sssParameters.halfRcpWeightedVariances);
-                    // Perform the horizontal SSS filtering pass, and combine diffuse and specular lighting into 'm_CameraColorBufferRT'.
-                    CoreUtils.DrawFullScreen(cmd, m_SssHorizontalFilterAndCombinePass, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT);
-                }
-            }
         }
 
         void UpdateSkyEnvironment(HDCamera hdCamera, CommandBuffer cmd)
             }
         }
 
-        void InitAndClearBuffer(HDCamera camera, bool enableBakeShadowMask, CommandBuffer cmd)
+        void InitAndClearBuffer(HDCamera hdCamera, bool enableBakeShadowMask, CommandBuffer cmd)
         {
             using (new ProfilingSample(cmd, "InitAndClearBuffer", GetSampler(CustomSamplerId.InitAndClearBuffer)))
             {
                     // Also we manage ourself the HDR format, here allocating fp16 directly.
                     // With scriptable render loop we can allocate temporary RT in a command buffer, they will not be release with ExecuteCommandBuffer
                     // These temporary surface are release automatically at the end of the scriptable render pipeline if not release explicitly
-                    int w = camera.camera.pixelWidth;
-                    int h = camera.camera.pixelHeight;
+                    int w = hdCamera.camera.pixelWidth;
+                    int h = hdCamera.camera.pixelHeight;
-                    if (NeedTemporarySubsurfaceBuffer())
-                    {
-                        cmd.GetTemporaryRT(m_CameraFilteringBuffer,      w, h, 0, FilterMode.Point, RenderTextureFormat.RGB111110Float, RenderTextureReadWrite.Linear, 1, true); // Enable UAV
-                    }
 
                     // Color and depth pyramids
                     int s = CalculatePyramidSize(w, h);
                     cmd.GetTemporaryRT(m_DepthPyramidBuffer, m_DepthPyramidBufferDesc, FilterMode.Trilinear);
                     // End
 
-                    if (!camera.useForwardOnly)
+                    if (!hdCamera.useForwardOnly)
-                        m_SSSBufferManager.InitGBuffers(w, h, m_GbufferManager, cmd);
+                        m_SSSBufferManager.InitSSSBuffersFromGBuffer(w, h, m_GbufferManager, cmd);
-                        m_SSSBufferManager.InitGBuffers(w, h, cmd);
+                        m_SSSBufferManager.InitSSSBuffers(w, h, cmd);
                     }
 
                     m_DbufferManager.InitDBuffers(w, h, cmd);
                     CoreUtils.SetRenderTarget(cmd, m_CameraSssDiffuseLightingBufferRT, ClearFlag.Color, CoreUtils.clearColorAllBlack);
                 }
 
-                // Old SSS Model >>>
-                if (NeedTemporarySubsurfaceBuffer())
-                {
-                    // Clear the SSS filtering target
-                    using (new ProfilingSample(cmd, "Clear SSS filtering target", GetSampler(CustomSamplerId.ClearSSSFilteringTarget)))
-                    {
-                        CoreUtils.SetRenderTarget(cmd, m_CameraFilteringBuffer, ClearFlag.Color, CoreUtils.clearColorAllBlack);
-                    }
-                }
-                // <<< Old SSS Model
-
-                    Color clearColor = camera.camera.backgroundColor.linear; // Need it in linear because we clear a linear fp16 texture.
+                    Color clearColor = hdCamera.camera.backgroundColor.linear; // Need it in linear because we clear a linear fp16 texture.
-                if (!camera.useForwardOnly)
+                if (!hdCamera.useForwardOnly)
                 {
                     using (new ProfilingSample(cmd, "Clear GBuffer", GetSampler(CustomSamplerId.ClearGBuffer)))
                     {

ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipelineAsset.asset

   m_Script: {fileID: 11500000, guid: 0cf1dab834d4ec34195b920ea7bbf9ec, type: 3}
   m_Name: HDRenderPipelineAsset
   m_EditorClassIdentifier: 
-  m_RenderPipelineResources: {fileID: 11400000, guid: 42086e81f4f0c724f96f7f09cc995354,
+  m_RenderPipelineResources: {fileID: 11400000, guid: 3ce144cff5783da45aa5d4fdc2da14b7,
     type: 2}
   globalRenderingSettings:
     useForwardRenderingOnly: 0
     reflectionCubemapSize: 128
     reflectionCacheCompressed: 0
   sssSettings: {fileID: 11400000, guid: c4d57f106d34d0046a33b3e66da29a72, type: 2}
-  tileSettings:
+  lightLoopSettings:
     enableTileAndCluster: 1
     enableComputeLightEvaluation: 1
     enableComputeLightVariants: 1

ScriptableRenderPipeline/HDRenderPipeline/HDStringConstants.cs

         public static readonly int _ThicknessRemaps = Shader.PropertyToID("_ThicknessRemaps");
         public static readonly int _ShapeParams = Shader.PropertyToID("_ShapeParams");
         public static readonly int _HalfRcpVariancesAndWeights = Shader.PropertyToID("_HalfRcpVariancesAndWeights");
-        public static readonly int _TransmissionTints = Shader.PropertyToID("_TransmissionTints");
+        public static readonly int _TransmissionTintsAndFresnel0 = Shader.PropertyToID("_TransmissionTintsAndFresnel0");
         public static readonly int specularLightingUAV = Shader.PropertyToID("specularLightingUAV");
         public static readonly int diffuseLightingUAV = Shader.PropertyToID("diffuseLightingUAV");
 
         public static readonly int _DstBlend = Shader.PropertyToID("_DstBlend");
 
         public static readonly int _HTile = Shader.PropertyToID("_HTile");
+        public static readonly int _SSSHTile = Shader.PropertyToID("_SSSHTile");
         public static readonly int _StencilTexture = Shader.PropertyToID("_StencilTexture");
 
         public static readonly int _ViewMatrix = Shader.PropertyToID("_ViewMatrix");
 
         public static readonly int[] _DBufferTexture =
         {
-            Shader.PropertyToID("_DBufferTexture0"), 
+            Shader.PropertyToID("_DBufferTexture0"),
-        public static readonly int[] _SSSBufferTexture = 
+        public static readonly int[] _SSSBufferTexture =
         {
             Shader.PropertyToID("_SSSBufferTexture0"),
             Shader.PropertyToID("_SSSBufferTexture1"),

ScriptableRenderPipeline/HDRenderPipeline/Lighting/LightLoop/LightLoop.hlsl

                 lightData = FetchLight(lightStart, min(++i, last));
             }
 
-            while (i <= last && lightData.lightType == GPULIGHTTYPE_RECTANGLE)
+            while (i <= last) // GPULIGHTTYPE_RECTANGLE
             {
                 lightData.lightType = GPULIGHTTYPE_RECTANGLE; // Enforce constant propagation
 

ScriptableRenderPipeline/HDRenderPipeline/Lighting/Lighting.hlsl

 
 #include "ShaderLibrary/CommonLighting.hlsl"
 #include "ShaderLibrary/CommonShadow.hlsl"
-#include "ShaderLibrary/Sampling.hlsl"
+#include "ShaderLibrary/Sampling/Sampling.hlsl"
 #include "ShaderLibrary/AreaLighting.hlsl"
 #include "ShaderLibrary/ImageBasedLighting.hlsl"
 

ScriptableRenderPipeline/HDRenderPipeline/Material/GGXConvolution/RuntimeFilterIBL.cs

         Matrix4x4[]   m_faceWorldToViewMatrixMatrices     = new Matrix4x4[6];
 
 
-        RenderPipelineResources m_RenderPipelinesResources;
+        RenderPipelineResources m_RenderPipelineResources;
 
         public bool supportMis
         {
-        public IBLFilterGGX(RenderPipelineResources renderPipelinesResources)
+        public IBLFilterGGX(RenderPipelineResources renderPipelineResources)
-            m_RenderPipelinesResources = renderPipelinesResources;
+            m_RenderPipelineResources = renderPipelineResources;
         }
 
         public bool IsInitialized()
         {
             if (!m_ComputeGgxIblSampleDataCS)
             {
-                m_ComputeGgxIblSampleDataCS     = m_RenderPipelinesResources.computeGgxIblSampleData;
+                m_ComputeGgxIblSampleDataCS     = m_RenderPipelineResources.computeGgxIblSampleData;
-                m_BuildProbabilityTablesCS   = m_RenderPipelinesResources.buildProbabilityTables;
+                m_BuildProbabilityTablesCS   = m_RenderPipelineResources.buildProbabilityTables;
                 m_ConditionalDensitiesKernel = m_BuildProbabilityTablesCS.FindKernel("ComputeConditionalDensities");
                 m_MarginalRowDensitiesKernel = m_BuildProbabilityTablesCS.FindKernel("ComputeMarginalRowDensities");
             }
-                m_GgxConvolveMaterial = CoreUtils.CreateEngineMaterial(m_RenderPipelinesResources.GGXConvolve);
+                m_GgxConvolveMaterial = CoreUtils.CreateEngineMaterial(m_RenderPipelineResources.GGXConvolve);
             }
 
             if (!m_GgxIblSampleData)

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.cs

             public static int s_GBufferLitStandardSpecularColorId = 1;
 
             public static float s_DefaultSpecularValue = 0.04f;
-            public static float s_SkinSpecularValue = 0.028f;
         }
 
         [GenerateHLSL(PackingRules.Exact)]

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

 #define GBUFFER_LIT_STANDARD_REGULAR_ID (0)
 #define GBUFFER_LIT_STANDARD_SPECULAR_COLOR_ID (1)
 #define DEFAULT_SPECULAR_VALUE (0.04)
-#define SKIN_SPECULAR_VALUE (0.028)
 
 //
 // UnityEngine.Experimental.Rendering.HDPipeline.Lit+RefractionMode:  static fields

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.hlsl

         if (_UseDisneySSS != 0)
         {
             bsdfData.transmittance = ComputeTransmittanceDisney(_ShapeParams[subsurfaceProfile].rgb,
-                                                                _TransmissionTints[subsurfaceProfile].rgb,
+                                                                _TransmissionTintsAndFresnel0[subsurfaceProfile].rgb,
                                                                 bsdfData.thickness, bsdfData.subsurfaceRadius);
         }
         else
                                                                  _HalfRcpVariancesAndWeights[subsurfaceProfile][1].rgb,
                                                                  _HalfRcpVariancesAndWeights[subsurfaceProfile][1].a,
-                                                                 _TransmissionTints[subsurfaceProfile].rgb,
+                                                                 _TransmissionTintsAndFresnel0[subsurfaceProfile].rgb,
                                                                  bsdfData.thickness, bsdfData.subsurfaceRadius);
         }
     }
     else if (bsdfData.materialId == MATERIALID_LIT_SSS)
     {
         bsdfData.diffuseColor = surfaceData.baseColor;
-        bsdfData.fresnel0     = SKIN_SPECULAR_VALUE; // TODO: take from the SSS profile
+        bsdfData.fresnel0     = _TransmissionTintsAndFresnel0[surfaceData.subsurfaceProfile].a;
         uint transmissionMode = BitFieldExtract(asuint(_TransmissionFlags), 2u * surfaceData.subsurfaceProfile, 2u);
 
         FillMaterialIdSssData(surfaceData.subsurfaceProfile,
             radius            = sssData.subsurfaceRadius;
             thickness         = inGBuffer2.g;
 
-            dielectricF0      = SKIN_SPECULAR_VALUE; // TODO: take from the SSS profile
+            dielectricF0      = _TransmissionTintsAndFresnel0[subsurfaceProfile].a;
         }
 
         FillMaterialIdSssData(subsurfaceProfile, radius, thickness, transmissionMode, bsdfData);
 // we need to push the shading position back to avoid self-shadowing problems.
 float3 ComputeThicknessDisplacement(BSDFData bsdfData, float3 L, float NdotL)
 {
-    // Compute the thickness in world units along the normal.
-    float thicknessInMeters = bsdfData.thickness * METERS_PER_MILLIMETER;
-    float thicknessInUnits  = thicknessInMeters * _WorldScales[bsdfData.subsurfaceProfile].y;
+    float displacement = 0;
+
+    [flatten] if (bsdfData.useThickObjectMode && NdotL < 0)
+    {
+        // Compute the thickness in world units along the normal.
+        float thicknessInMeters = bsdfData.thickness * METERS_PER_MILLIMETER;
+        float thicknessInUnits  = thicknessInMeters * _WorldScales[bsdfData.subsurfaceProfile].y;
-    // Compute the thickness in world units along the light vector.
-    float unprojectedThickness = thicknessInUnits / -NdotL;
+        // Compute the thickness in world units along the light vector.
+        displacement = thicknessInUnits / -NdotL;
+    }
-    return unprojectedThickness * L;
+    return displacement * L;
 }
 
 // Currently, we only model diffuse transmission. Specular transmission is not yet supported.
     float3 L     = -lightData.forward; // Lights point backward in Unity
     float  NdotL = dot(N, L);
 
-    [flatten] if (bsdfData.useThickObjectMode && NdotL < 0)
-    {
-        posInput.positionWS += ComputeThicknessDisplacement(bsdfData, L, NdotL);
-    }
+    posInput.positionWS += ComputeThicknessDisplacement(bsdfData, L, NdotL);
 
     float3 color; float attenuation;
     EvaluateLight_Directional(lightLoopContext, posInput, lightData, bakeLightingData, N, L,
 
-    [branch] if (intensity > 0.0)
+    [branch] if (intensity > 0)
     {
         BSDF(V, L, posInput.positionWS, preLightData, bsdfData, lighting.diffuse, lighting.specular);
 
 
-    [flatten] if (bsdfData.enableTransmission)
+    [branch] if (bsdfData.enableTransmission)
     {
         // We use diffuse lighting for accumulation since it is going to be blurred during the SSS pass.
         lighting.diffuse += EvaluateTransmission(bsdfData, NdotL, preLightData.NdotV, attenuation * lightData.diffuseScale);
     float3 L       = unL * distRcp;
     float  NdotL   = dot(N, L);
 
-    [flatten] if (bsdfData.useThickObjectMode && NdotL < 0)
-    {
-        posInput.positionWS += ComputeThicknessDisplacement(bsdfData, L, NdotL);
-    }
+    posInput.positionWS += ComputeThicknessDisplacement(bsdfData, L, NdotL);
 
     float3 color; float attenuation;
     EvaluateLight_Punctual(lightLoopContext, posInput, lightData, bakeLightingData, N, L, dist, distSq,
 
-    [branch] if (intensity > 0.0)
+    [branch] if (intensity > 0)
     {
         // Simulate a sphere light with this hack.
         bsdfData.roughnessT = max(bsdfData.roughnessT, lightData.minRoughness);
         lighting.specular *= intensity * lightData.specularScale;
     }
 
-    [flatten] if (bsdfData.enableTransmission)
+    [branch] if (bsdfData.enableTransmission)
     {
         // We use diffuse lighting for accumulation since it is going to be blurred during the SSS pass.
         lighting.diffuse += EvaluateTransmission(bsdfData, NdotL, preLightData.NdotV, attenuation * lightData.diffuseScale);

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LitData.hlsl

 //-------------------------------------------------------------------------------------
 // Fill SurfaceData/Builtin data function
 //-------------------------------------------------------------------------------------
-#include "ShaderLibrary/SampleUVMapping.hlsl"
+#include "ShaderLibrary/Sampling/SampleUVMapping.hlsl"
 #include "../MaterialUtilities.hlsl"
 #include "../Decal/DecalUtilities.hlsl"
 

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LitDataMeshModification.hlsl

     return ComputePerVertexDisplacement(layerTexCoord, vertexColor, lod) * normalWS;
 }
 
-void ApplyVertexModification(AttributesMesh input, float3 normalWS, inout float3 positionWS)
+void ApplyVertexModification(AttributesMesh input, float3 normalWS, inout float3 positionWS, float4 time)
 {
 #if defined(_VERTEX_DISPLACEMENT)
 
     
 #ifdef _VERTEX_WIND
     float3 rootWP = mul(GetObjectToWorldMatrix(), float4(0, 0, 0, 1)).xyz;
-    ApplyWindDisplacement(positionWS, normalWS, rootWP, _Stiffness, _Drag, _ShiverDrag, _ShiverDirectionality, _InitialBend, input.color.a, _Time);
+    ApplyWindDisplacement(positionWS, normalWS, rootWP, _Stiffness, _Drag, _ShiverDrag, _ShiverDirectionality, _InitialBend, input.color.a, time);
 #endif
 }
 

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/ShaderPass/LitVelocityPass.hlsl

 // conflict with the normal in the semantic. This need to be fix! Also no per pixel displacement is possible either.
 
 // Attributes
-#define REQUIRE_TANGENT_TO_WORLD 0 /* defined(_PIXEL_DISPLACEMENT) */
-#define REQUIRE_NORMAL 0 /*  defined(TESSELLATION_ON) || REQUIRE_TANGENT_TO_WORLD || defined(_VERTEX_WIND) || defined(_VERTEX_DISPLACEMENT) */
+#define REQUIRE_TANGENT_TO_WORLD defined(_PIXEL_DISPLACEMENT)
+#define REQUIRE_NORMAL defined(TESSELLATION_ON) || REQUIRE_TANGENT_TO_WORLD || defined(_VERTEX_WIND) || defined(_VERTEX_DISPLACEMENT)
 #define REQUIRE_VERTEX_COLOR ((defined(_VERTEX_DISPLACEMENT) || defined(_TESSELLATION_DISPLACEMENT)) && defined(LAYERED_LIT_SHADER) && (defined(_LAYER_MASK_VERTEX_COLOR_MUL) || defined(_LAYER_MASK_VERTEX_COLOR_ADD))) || defined(_VERTEX_WIND)
 
 // This first set of define allow to say which attributes will be use by the mesh in the vertex and domain shader (for tesselation)

ScriptableRenderPipeline/HDRenderPipeline/Material/SubsurfaceScattering/SubsurfaceScattering.hlsl

 // Use float4 to avoid any packing issue between compute and pixel shaders
 float4  _ThicknessRemaps[SSS_N_PROFILES];   // R: start, G = end - start, BA unused
 float4 _ShapeParams[SSS_N_PROFILES];        // RGB = S = 1 / D, A = filter radius
-float4 _TransmissionTints[SSS_N_PROFILES];  // RGB = 1/4 * color, A = unused
+float4 _TransmissionTintsAndFresnel0[SSS_N_PROFILES];  // RGB = 1/4 * color, A = fresnel0
 float4 _WorldScales[SSS_N_PROFILES];        // X = meters per world unit; Y = world units per meter
 CBUFFER_END
 

ScriptableRenderPipeline/HDRenderPipeline/Material/SubsurfaceScattering/SubsurfaceScatteringManager.cs

         RenderTargetIdentifier[] m_ColorMRTs;
         RenderTargetIdentifier[] m_RTIDs = new RenderTargetIdentifier[k_MaxSSSBuffer];
 
+        // Disney SSS Model
+        ComputeShader m_SubsurfaceScatteringCS;
+        int m_SubsurfaceScatteringKernel;
+        Material m_CombineLightingPass;
+
+        RenderTexture m_HTile;
+        RenderTargetIdentifier m_HTileRT;
+        // End Disney SSS Model
+
+        // Jimenez SSS Model
+        Material m_SssVerticalFilterPass;
+        Material m_SssHorizontalFilterAndCombinePass;
+        // End Jimenez SSS Model
+
+        // Jimenez need an extra buffer and Disney need one for some platform
+        readonly int m_CameraFilteringBuffer;
+        readonly RenderTargetIdentifier m_CameraFilteringBufferRT;
+
+        // This is use to be able to read stencil value in compute shader
+        Material m_CopyStencilForSplitLighting;
+
+        SubsurfaceScatteringSettings m_sssSettings;
+
+
+            // Use with Jimenez
+            m_CameraFilteringBuffer = HDShaderIDs._CameraFilteringBuffer;
+            m_CameraFilteringBufferRT = new RenderTargetIdentifier(m_CameraFilteringBuffer);
-        public void InitGBuffers(int width, int height, GBufferManager gbufferManager, CommandBuffer cmd)
+        public void InitSSSBuffersFromGBuffer(int width, int height, GBufferManager gbufferManager, CommandBuffer cmd)
         {
             m_RTIDs[0] = gbufferManager.GetGBuffers()[0];
         }
-        public void InitGBuffers(int width, int height, CommandBuffer cmd)
+        public void InitSSSBuffers(int width, int height, CommandBuffer cmd)
-            cmd.GetTemporaryRT(m_SSSBuffer0, width, height, 0, FilterMode.Point, RenderTextureFormat.ARGB32, RenderTextureReadWrite.Linear);            
+            cmd.GetTemporaryRT(m_SSSBuffer0, width, height, 0, FilterMode.Point, RenderTextureFormat.ARGB32, RenderTextureReadWrite.Linear);
         }
 
         public RenderTargetIdentifier GetSSSBuffers(int index)
+        }
+
+        public void Build(RenderPipelineResources renderPipelineResources, SubsurfaceScatteringSettings sssSettings)
+        {
+            m_sssSettings = sssSettings;
+            // Disney SSS (compute + combine)
+            m_SubsurfaceScatteringCS = renderPipelineResources.subsurfaceScatteringCS;
+            m_SubsurfaceScatteringKernel = m_SubsurfaceScatteringCS.FindKernel("SubsurfaceScattering");
+            m_CombineLightingPass = CoreUtils.CreateEngineMaterial(renderPipelineResources.combineLighting);
+
+            // Jimenez SSS Model (shader)
+            m_SssVerticalFilterPass = CoreUtils.CreateEngineMaterial(renderPipelineResources.subsurfaceScattering);
+            m_SssVerticalFilterPass.DisableKeyword("SSS_FILTER_HORIZONTAL_AND_COMBINE");
+            m_SssVerticalFilterPass.SetFloat(HDShaderIDs._DstBlend, (float)BlendMode.Zero);
+
+            m_SssHorizontalFilterAndCombinePass = CoreUtils.CreateEngineMaterial(renderPipelineResources.subsurfaceScattering);
+            m_SssHorizontalFilterAndCombinePass.EnableKeyword("SSS_FILTER_HORIZONTAL_AND_COMBINE");
+            m_SssHorizontalFilterAndCombinePass.SetFloat(HDShaderIDs._DstBlend, (float)BlendMode.One);
+
+            m_CopyStencilForSplitLighting = CoreUtils.CreateEngineMaterial(renderPipelineResources.copyStencilBuffer);
+            m_CopyStencilForSplitLighting.SetInt(HDShaderIDs._StencilRef, (int)StencilLightingUsage.SplitLighting);
+        }
+
+        public void Cleanup()
+        {
+            CoreUtils.Destroy(m_CombineLightingPass);
+            CoreUtils.Destroy(m_SssVerticalFilterPass);
+            CoreUtils.Destroy(m_SssHorizontalFilterAndCombinePass);
+            CoreUtils.Destroy(m_CopyStencilForSplitLighting);
+        }
+
+        public void Resize(Camera camera)
+        {
+            // We must use a RenderTexture and not GetTemporaryRT() as currently Unity only aloow to bind a RenderTexture for a UAV in a pixel shader
+            // We use 8x8 tiles in order to match the native GCN HTile as closely as possible.
+            m_HTile = new RenderTexture((camera.pixelWidth + 7) / 8, (camera.pixelHeight + 7) / 8, 0, RenderTextureFormat.R8, RenderTextureReadWrite.Linear); // DXGI_FORMAT_R8_UINT is not supported by Unity
+            m_HTile.filterMode = FilterMode.Point;
+            m_HTile.enableRandomWrite = true;
+            m_HTile.Create();
+            m_HTileRT = new RenderTargetIdentifier(m_HTile);
+        }
+
+        public void PushGlobalParams(CommandBuffer cmd, SubsurfaceScatteringSettings sssParameters, DebugDisplaySettings debugDisplaySettings)
+        {
+            // Broadcast SSS parameters to all shaders.
+            cmd.SetGlobalInt(HDShaderIDs._EnableSSSAndTransmission, debugDisplaySettings.renderingDebugSettings.enableSSSAndTransmission ? 1 : 0);
+            cmd.SetGlobalInt(HDShaderIDs._UseDisneySSS, sssParameters.useDisneySSS ? 1 : 0);
+            unsafe
+            {
+                // Warning: Unity is not able to losslessly transfer integers larger than 2^24 to the shader system.
+                // Therefore, we bitcast uint to float in C#, and bitcast back to uint in the shader.
+                uint texturingModeFlags = sssParameters.texturingModeFlags;
+                uint transmissionFlags = sssParameters.transmissionFlags;
+                cmd.SetGlobalFloat(HDShaderIDs._TexturingModeFlags, *(float*)&texturingModeFlags);
+                cmd.SetGlobalFloat(HDShaderIDs._TransmissionFlags, *(float*)&transmissionFlags);
+            }
+            cmd.SetGlobalVectorArray(HDShaderIDs._ThicknessRemaps, sssParameters.thicknessRemaps);
+            cmd.SetGlobalVectorArray(HDShaderIDs._ShapeParams, sssParameters.shapeParams);
+            cmd.SetGlobalVectorArray(HDShaderIDs._HalfRcpVariancesAndWeights, sssParameters.halfRcpVariancesAndWeights);
+            cmd.SetGlobalVectorArray(HDShaderIDs._TransmissionTintsAndFresnel0, sssParameters.transmissionTintsAndFresnel0);
+            cmd.SetGlobalVectorArray(HDShaderIDs._WorldScales, sssParameters.worldScales);
+        }
+
+        bool NeedTemporarySubsurfaceBuffer()
+        {
+            // Caution: need to be in sync with SubsurfaceScattering.cs USE_INTERMEDIATE_BUFFER (Can't make a keyword as it is a compute shader)
+            // Typed UAV loads from FORMAT_R16G16B16A16_FLOAT is an optional feature of Direct3D 11.
+            // Most modern GPUs support it. We can avoid performing a costly copy in this case.
+            // TODO: test/implement for other platforms.
+            return SystemInfo.graphicsDeviceType != GraphicsDeviceType.PlayStation4 &&
+                    SystemInfo.graphicsDeviceType != GraphicsDeviceType.XboxOne &&
+                    SystemInfo.graphicsDeviceType != GraphicsDeviceType.XboxOneD3D12;
+        }
+
+        // Combines specular lighting and diffuse lighting with subsurface scattering.
+        public void SubsurfaceScatteringPass(HDCamera hdCamera, CommandBuffer cmd, SubsurfaceScatteringSettings sssParameters, DebugDisplaySettings debugDisplaySettings,
+                                            RenderTargetIdentifier colorBufferRT, RenderTargetIdentifier diffuseBufferRT, RenderTargetIdentifier depthStencilBufferRT, RenderTargetIdentifier depthTextureRT)
+        {
+            if (m_sssSettings == null || !debugDisplaySettings.renderingDebugSettings.enableSSSAndTransmission)
+                return;
+
+            using (new ProfilingSample(cmd, "Subsurface Scattering", HDRenderPipeline.GetSampler(CustomSamplerId.SubsurfaceScattering)))
+            {
+                int w = hdCamera.camera.pixelWidth;
+                int h = hdCamera.camera.pixelHeight;
+
+                // For Jimenez we always need an extra buffer, for Disney it depends on platform
+                if (!m_sssSettings.useDisneySSS ||
+                    (m_sssSettings.useDisneySSS && NeedTemporarySubsurfaceBuffer()))
+                {
+                    // Caution: must be same format as m_CameraSssDiffuseLightingBuffer
+                    cmd.ReleaseTemporaryRT(m_CameraFilteringBuffer);
+                    cmd.GetTemporaryRT(m_CameraFilteringBuffer, w, h, 0, FilterMode.Point, RenderTextureFormat.RGB111110Float, RenderTextureReadWrite.Linear, 1, true); // Enable UAV
+                                                                                                                                                                        // Clear the SSS filtering target
+                    using (new ProfilingSample(cmd, "Clear SSS filtering target", HDRenderPipeline.GetSampler(CustomSamplerId.ClearSSSFilteringTarget)))
+                    {
+                        CoreUtils.SetRenderTarget(cmd, m_CameraFilteringBufferRT, ClearFlag.Color, CoreUtils.clearColorAllBlack);
+                    }
+                }
+
+                if (m_sssSettings.useDisneySSS)
+                {
+                    using (new ProfilingSample(cmd, "HTile for SSS", HDRenderPipeline.GetSampler(CustomSamplerId.HTileForSSS)))
+                    {
+                        // Currently, Unity does not offer a way to access the GCN HTile even on PS4 and Xbox One.
+                        // Therefore, it's computed in a pixel shader, and optimized to only contain the SSS bit.
+                        CoreUtils.SetRenderTarget(cmd, m_HTileRT, ClearFlag.Color, CoreUtils.clearColorAllBlack);
+
+                        cmd.SetRandomWriteTarget(1, m_HTile);
+                        // Generate HTile for the split lighting stencil usage. Don't write into stencil texture (shaderPassId = 2)
+                        // Use ShaderPassID 1 => "Pass 2 - Export HTILE for stencilRef to output"
+                        CoreUtils.SetRenderTarget(cmd, depthStencilBufferRT); // No need for color buffer here
+                        CoreUtils.DrawFullScreen(cmd, m_CopyStencilForSplitLighting, null, 2);
+                        cmd.ClearRandomWriteTargets();
+                    }
+
+                    // TODO: Remove this once fix, see comment inside the function
+                    hdCamera.SetupComputeShader(m_SubsurfaceScatteringCS, cmd);
+
+                    unsafe
+                    {
+                        // Warning: Unity is not able to losslessly transfer integers larger than 2^24 to the shader system.
+                        // Therefore, we bitcast uint to float in C#, and bitcast back to uint in the shader.
+                        uint texturingModeFlags = sssParameters.texturingModeFlags;
+                        cmd.SetComputeFloatParam(m_SubsurfaceScatteringCS, HDShaderIDs._TexturingModeFlags, *(float*)&texturingModeFlags);
+                    }
+
+                    cmd.SetComputeVectorArrayParam(m_SubsurfaceScatteringCS, HDShaderIDs._WorldScales,        sssParameters.worldScales);
+                    cmd.SetComputeVectorArrayParam(m_SubsurfaceScatteringCS, HDShaderIDs._FilterKernels,      sssParameters.filterKernels);
+                    cmd.SetComputeVectorArrayParam(m_SubsurfaceScatteringCS, HDShaderIDs._ShapeParams,        sssParameters.shapeParams);
+
+                    cmd.SetComputeTextureParam(m_SubsurfaceScatteringCS, m_SubsurfaceScatteringKernel, HDShaderIDs._DepthTexture,       depthTextureRT);
+                    cmd.SetComputeTextureParam(m_SubsurfaceScatteringCS, m_SubsurfaceScatteringKernel, HDShaderIDs._SSSHTile,           m_HTileRT);
+                    cmd.SetComputeTextureParam(m_SubsurfaceScatteringCS, m_SubsurfaceScatteringKernel, HDShaderIDs._IrradianceSource,   diffuseBufferRT);
+
+                    for (int i = 0; i < sssBufferCount; ++i)
+                    {
+                        cmd.SetComputeTextureParam(m_SubsurfaceScatteringCS, m_SubsurfaceScatteringKernel, HDShaderIDs._SSSBufferTexture[i], GetSSSBuffers(i));
+                    }
+
+                    if (NeedTemporarySubsurfaceBuffer())
+                    {
+                        // Caution: must be same format as m_CameraSssDiffuseLightingBuffer
+                        cmd.ReleaseTemporaryRT(m_CameraFilteringBuffer);
+                        cmd.GetTemporaryRT(m_CameraFilteringBuffer, w, h, 0, FilterMode.Point, RenderTextureFormat.RGB111110Float, RenderTextureReadWrite.Linear, 1, true); // Enable UAV
+                        // Clear the SSS filtering target
+                        using (new ProfilingSample(cmd, "Clear SSS filtering target", HDRenderPipeline.GetSampler(CustomSamplerId.ClearSSSFilteringTarget)))
+                        {
+                            CoreUtils.SetRenderTarget(cmd, m_CameraFilteringBufferRT, ClearFlag.Color, CoreUtils.clearColorAllBlack);
+                        }
+
+                        cmd.SetComputeTextureParam(m_SubsurfaceScatteringCS, m_SubsurfaceScatteringKernel, HDShaderIDs._CameraFilteringBuffer, m_CameraFilteringBufferRT);
+
+                        // Perform the SSS filtering pass which fills 'm_CameraFilteringBufferRT'.
+                        // We dispatch 4x swizzled 16x16 groups per a 32x32 macro tile.
+                        cmd.DispatchCompute(m_SubsurfaceScatteringCS, m_SubsurfaceScatteringKernel, 4, ((int)hdCamera.screenSize.x + 31) / 32, ((int)hdCamera.screenSize.y + 31) / 32);
+
+                        cmd.SetGlobalTexture(HDShaderIDs._IrradianceSource, m_CameraFilteringBufferRT);  // Cannot set a RT on a material
+
+                        // Additively blend diffuse and specular lighting into 'm_CameraColorBufferRT'.
+                        CoreUtils.DrawFullScreen(cmd, m_CombineLightingPass, colorBufferRT, depthStencilBufferRT);
+                    }
+                    else
+                    {
+                        cmd.SetComputeTextureParam(m_SubsurfaceScatteringCS, m_SubsurfaceScatteringKernel, HDShaderIDs._CameraColorTexture, colorBufferRT);
+
+                        // Perform the SSS filtering pass which performs an in-place update of 'colorBuffer'.
+                        // We dispatch 4x swizzled 16x16 groups per a 32x32 macro tile.
+                        cmd.DispatchCompute(m_SubsurfaceScatteringCS, m_SubsurfaceScatteringKernel, 4, ((int)hdCamera.screenSize.x + 31) / 32, ((int)hdCamera.screenSize.y + 31) / 32);
+                    }
+                }
+                else
+                {
+                    for (int i = 0; i < sssBufferCount; ++i)
+                    {
+                        cmd.SetGlobalTexture(HDShaderIDs._SSSBufferTexture[i], GetSSSBuffers(i));
+                    }
+
+                    cmd.SetGlobalTexture(HDShaderIDs._IrradianceSource, diffuseBufferRT);  // Cannot set a RT on a material
+                    m_SssVerticalFilterPass.SetVectorArray(HDShaderIDs._FilterKernelsBasic,       sssParameters.filterKernelsBasic);
+                    m_SssVerticalFilterPass.SetVectorArray(HDShaderIDs._HalfRcpWeightedVariances, sssParameters.halfRcpWeightedVariances);
+                    // Perform the vertical SSS filtering pass which fills 'm_CameraFilteringBufferRT'.
+                    CoreUtils.DrawFullScreen(cmd, m_SssVerticalFilterPass, m_CameraFilteringBufferRT, depthStencilBufferRT);
+
+                    cmd.SetGlobalTexture(HDShaderIDs._IrradianceSource, m_CameraFilteringBufferRT);  // Cannot set a RT on a material
+                    m_SssHorizontalFilterAndCombinePass.SetVectorArray(HDShaderIDs._FilterKernelsBasic,       sssParameters.filterKernelsBasic);
+                    m_SssHorizontalFilterAndCombinePass.SetVectorArray(HDShaderIDs._HalfRcpWeightedVariances, sssParameters.halfRcpWeightedVariances);
+                    // Perform the horizontal SSS filtering pass, and combine diffuse and specular lighting into 'm_CameraColorBufferRT'.
+                    CoreUtils.DrawFullScreen(cmd, m_SssHorizontalFilterAndCombinePass, colorBufferRT, depthStencilBufferRT);
+                }
+            }
         }
     }
 }

ScriptableRenderPipeline/HDRenderPipeline/Material/SubsurfaceScattering/SubsurfaceScatteringSettings.cs

         public TransmissionMode transmissionMode;
         public Vector2          thicknessRemap;             // X = min, Y = max (in millimeters)
         public float            worldScale;                 // Size of the world unit in meters
+        public float            fresnel0;                   // Fresnel0, 0.028 for skin
 
         // Old SSS Model >>>
         [ColorUsage(false, true)]
             transmissionMode   = TransmissionMode.None;
             thicknessRemap     = new Vector2(0f, 5f);
             worldScale         = 1f;
+            fresnel0           = 0.028f; // TYpical value for skin specular reflectance
 
             // Old SSS Model >>>
             scatterDistance1   = new Color(0.3f, 0.3f, 0.3f, 0f);
             thicknessRemap.y = Mathf.Max(thicknessRemap.y, 0f);
             thicknessRemap.x = Mathf.Clamp(thicknessRemap.x, 0f, thicknessRemap.y);
             worldScale       = Mathf.Max(worldScale, 0.001f);
+            fresnel0         = Mathf.Clamp(fresnel0, 0.0f, 0.1f);
 
             // Old SSS Model >>>
             scatterDistance1 = new Color
         [NonSerialized] public Vector4[] thicknessRemaps;           // Remap: 0 = start, 1 = end - start
         [NonSerialized] public Vector4[] worldScales;               // X = meters per world unit; Y = world units per meter
         [NonSerialized] public Vector4[] shapeParams;               // RGB = S = 1 / D, A = filter radius
-        [NonSerialized] public Vector4[] transmissionTints;         // RGB = color, A = unused
+        [NonSerialized] public Vector4[] transmissionTintsAndFresnel0; // RGB = color, A = fresnel0
         [NonSerialized] public Vector4[] filterKernels;             // XY = near field, ZW = far field; 0 = radius, 1 = reciprocal of the PDF
 
         // Old SSS Model >>>
             ValidateArray(ref thicknessRemaps,   SssConstants.SSS_N_PROFILES);
             ValidateArray(ref worldScales,       SssConstants.SSS_N_PROFILES);
             ValidateArray(ref shapeParams,       SssConstants.SSS_N_PROFILES);
-            ValidateArray(ref transmissionTints, SssConstants.SSS_N_PROFILES);
+            ValidateArray(ref transmissionTintsAndFresnel0, SssConstants.SSS_N_PROFILES);
             ValidateArray(ref filterKernels,     SssConstants.SSS_N_PROFILES * SssConstants.SSS_N_SAMPLES_NEAR_FIELD);
 
             // Old SSS Model >>>
             worldScales[i]       = new Vector4(profiles[p].worldScale, 1.0f / profiles[p].worldScale, 0f, 0f);
             shapeParams[i]       = profiles[p].shapeParam;
             shapeParams[i].w     = profiles[p].maxRadius;
-            transmissionTints[i] = profiles[p].transmissionTint * 0.25f; // Premultiplied
+            transmissionTintsAndFresnel0[i] = new Vector4(profiles[p].transmissionTint.r * 0.25f, profiles[p].transmissionTint.g * 0.25f, profiles[p].transmissionTint.b * 0.25f, profiles[p].fresnel0); // Premultiplied
 
             for (int j = 0, n = SssConstants.SSS_N_SAMPLES_NEAR_FIELD; j < n; j++)
             {

ScriptableRenderPipeline/HDRenderPipeline/RenderPipelineResources/HDRenderPipelineResources.asset

   debugFullScreenShader: {fileID: 4800000, guid: e874aca2df8300a488258738c31f85cf,
     type: 3}
   deferredShader: {fileID: 4800000, guid: 00dd221e34a6ab349a1196b0f2fab693, type: 3}
-  screenSpaceAmbientOcclusionShader: {fileID: 4800000, guid: cf0db7f5267ad944dbf4326b7102c9ca,
-    type: 3}
-  subsurfaceScatteringCS: {fileID: 7200000, guid: b06a7993621def248addd55d0fe931b1,
-    type: 3}
-  volumetricLightingCS: {fileID: 7200000, guid: 799166e2ee6a4b041bba9e74f6942097,
-    type: 3}
-  copyChannelCS: {fileID: 7200000, guid: a68d8aaeb0956234d94e389f196381ee, type: 3}
+  copyChannelCS: {fileID: 7200000, guid: a4d45eda75e8e474dbe24a31f741f3b4, type: 3}
   applyDistortionCS: {fileID: 7200000, guid: 2fa6c0e3fe6dc3145a4156f21913fe5c, type: 3}
   clearDispatchIndirectShader: {fileID: 7200000, guid: fc1f553acb80a6446a32d33e403d0656,
     type: 3}
     type: 3}
   deferredDirectionalShadowComputeShader: {fileID: 7200000, guid: fbde6fae193b2a94e9fd97c163c204f4,
     type: 3}
+  subsurfaceScatteringCS: {fileID: 7200000, guid: b06a7993621def248addd55d0fe931b1,
+    type: 3}
+  subsurfaceScattering: {fileID: 4800000, guid: 867b36db983aa0548889a66f8d685ff6,
+    type: 3}
+  combineLighting: {fileID: 4800000, guid: 2e37131331fbdca449b1a2bc47a639ca, type: 3}
+  copyStencilBuffer: {fileID: 4800000, guid: 3d1574f1cdfa0ce4995f9bc79ed7f8ec, type: 3}
   blitCubemap: {fileID: 4800000, guid: d05913e251bed7a4992c921c62e1b647, type: 3}
   buildProbabilityTables: {fileID: 7200000, guid: b9f26cf340afe9145a699753531b2a4c,
     type: 3}

ScriptableRenderPipeline/HDRenderPipeline/RenderPipelineResources/HDRenderPipelineResources.asset.meta

 fileFormatVersion: 2
-guid: 42086e81f4f0c724f96f7f09cc995354
-timeCreated: 1507194928
-licenseType: Pro
+guid: 3ce144cff5783da45aa5d4fdc2da14b7
 NativeFormatImporter:
   externalObjects: {}
   mainObjectFileID: 11400000

ScriptableRenderPipeline/HDRenderPipeline/RenderPipelineResources/RenderPipelineResources.cs

 
         // Lighting resources
         public Shader deferredShader;
-        public Shader combineLightingPass;
-        public ComputeShader subsurfaceScatteringCS;
         public ComputeShader gaussianPyramidCS;
         public ComputeShader depthPyramidCS;
         public ComputeShader copyChannelCS;
         public ComputeShader deferredComputeShader;
         public ComputeShader deferredDirectionalShadowComputeShader;
 
-        // SceneSettings
+        // Subsurface scattering
+        public ComputeShader subsurfaceScatteringCS; // Disney SSS
+        public Shader subsurfaceScattering; // Jimenez SSS
+        public Shader combineLighting;
+
+        // General
+        public Shader copyStencilBuffer;
 
         // Sky
         public Shader blitCubemap;

ScriptableRenderPipeline/HDRenderPipeline/ShaderPass/ShaderPassVelocity.hlsl

 // Available semantic start from TEXCOORD4
 struct AttributesPass
 {
-    float3 previousPositionOS : NORMAL; // Contain previous transform position (in case of skinning for example)
-
-    // TODO: Caution - For now the tesselation doesn't displace along the normal with Velocity shader as the previous previous position
-    // conflict with the normal in the semantic. This need to be fix!
+    float3 previousPositionOS : TEXCOORD4; // Contain previous transform position (in case of skinning for example)
 };
 
 struct VaryingsPassToPS
 #define VARYINGS_NEED_PASS
 #include "VertMesh.hlsl"
 
+// Transforms normal from object to world space
+float3 TransformPreviousObjectToWorldNormal(float3 normalOS)
+{
+#ifdef UNITY_ASSUME_UNIFORM_SCALING
+    return normalize(mul((float3x3)unity_MatrixPreviousM, normalOS));
+#else
+    // Normal need to be multiply by inverse transpose
+    // mul(IT_M, norm) => mul(norm, I_M) => {dot(norm, I_M.col0), dot(norm, I_M.col1), dot(norm, I_M.col2)}
+    return normalize(mul(normalOS, (float3x3)unity_MatrixPreviousMI));
+#endif
+}
+
+void VelocityPositionZBias(VaryingsToPS input)
+{
+	#if defined(UNITY_REVERSED_Z)
+		input.vmesh.positionCS.z -= unity_MotionVectorsParams.z * input.vmesh.positionCS.w;
+	#else
+		input.vmesh.positionCS.z += unity_MotionVectorsParams.z * input.vmesh.positionCS.w;
+	#endif
+}
+
 PackedVaryingsType Vert(AttributesMesh inputMesh,
                         AttributesPass inputPass)
 {
+#if !defined(TESSELLATION_ON)
+	VelocityPositionZBias(varyingsType);
+#endif
+
-    varyingsType.vpass.positionCS = mul(_NonJitteredViewProjMatrix, mul(unity_ObjectToWorld, float4(inputMesh.positionOS, 1.0)));
-    varyingsType.vpass.previousPositionCS = mul(_PrevViewProjMatrix, mul(unity_MatrixPreviousM, unity_MotionVectorsParams.x ? float4(inputPass.previousPositionOS, 1.0) : float4(inputMesh.positionOS, 1.0)));
+	varyingsType.vpass.positionCS = mul(_NonJitteredViewProjMatrix, float4(varyingsType.vmesh.positionWS, 1.0));
+
+	//Need to apply any vertex animation to the previous worldspace position, if we want it to show up in the velocity buffer
+	float3 previousPositionWS = mul(unity_MatrixPreviousM, unity_MotionVectorsParams.x ? float4(inputPass.previousPositionOS, 1.0) : float4(inputMesh.positionOS, 1.0)).xyz;
+	#ifdef ATTRIBUTES_NEED_NORMAL
+		float3 normalWS = TransformPreviousObjectToWorldNormal(inputMesh.normalOS);
+	#else
+		float3 normalWS = float3(0.0, 0.0, 0.0);
+	#endif
+		
+	#if defined(HAVE_VERTEX_MODIFICATION)
+		ApplyVertexModification(inputMesh, normalWS, previousPositionWS, _LastTime);
+	#endif
+	
+	//Need this since we are using the current position from VertMesh()
+	previousPositionWS = GetCameraRelativePositionWS(previousPositionWS);
+	
+	varyingsType.vpass.previousPositionCS = mul(_PrevViewProjMatrix, float4(previousPositionWS, 1.0));
 
     return PackVaryingsType(varyingsType);
 }
     VaryingsToPS output;
 
     output.vmesh = VertMeshTesselation(input.vmesh);
+
+	VelocityPositionZBias(output);
 
     output.vpass.positionCS = input.vpass.positionCS;
     output.vpass.previousPositionCS = input.vpass.previousPositionCS;

ScriptableRenderPipeline/HDRenderPipeline/ShaderPass/VertMesh.hlsl

 
     // TODO: deal with camera center rendering and instancing (This is the reason why we always perform two  steps transform to clip space + instancing matrix)
 
-    // This code is disabled for velocity pass for now because at the moment we cannot have Normals with the velocity pass (this attributes holds last frame data)
-    // TODO: Remove the velocity pass test when velocity is properly handled.
-#if defined(HAVE_VERTEX_MODIFICATION) && (SHADERPASS != SHADERPASS_VELOCITY)
-    ApplyVertexModification(input, normalWS, positionWS);
+#if defined(HAVE_VERTEX_MODIFICATION)
+    ApplyVertexModification(input, normalWS, positionWS, _Time);
 #endif
 
     positionWS = GetCameraRelativePositionWS(positionWS);
-    // TODO: TEMP: Velocity has a flow as it doens't have normal. This need to be fix. In the mean time, generate fix normal so compiler doesn't complain - When fix, think to also enable ATTRIBUTES_NEED_NORMAL in LitVelocityPass.hlsl
-    #if (SHADERPASS == SHADERPASS_VELOCITY)
-    output.normalWS = float3(0.0, 0.0, 1.0);
-    #else
-    #endif
     #if defined(VARYINGS_NEED_TANGENT_TO_WORLD) || defined(VARYINGS_DS_NEED_TANGENT)
     output.tangentWS = tangentWS;
     #endif

ScriptableRenderPipeline/HDRenderPipeline/ShaderVariables.hlsl

 CBUFFER_START(UnityPerCamera)
     // Time (t = time since current level load) values from Unity
     float4 _Time; // (t/20, t, t*2, t*3)
+    float4 _LastTime; // Last frame time (t/20, t, t*2, t*3)
     float4 _SinTime; // sin(t/8), sin(t/4), sin(t/2), sin(t)
     float4 _CosTime; // cos(t/8), cos(t/4), cos(t/2), cos(t)
     float4 unity_DeltaTime; // dt, 1/dt, smoothdt, 1/smoothdt
     float4x4 unity_MatrixNonJitteredVP;
     float4x4 unity_MatrixPreviousVP;
     float4x4 unity_MatrixPreviousM;
+	float4x4 unity_MatrixPreviousMI;
+    //X : Use last frame positions (right now skinned meshes are the only objects that use this
+    //Y : Force No Motion
+    //Z : Z bias value
     float4 unity_MotionVectorsParams;
 CBUFFER_END
 

ScriptableRenderPipeline/HDRenderPipeline/Sky/SkyManager.cs

             RebuildSkyMatrices(nearPlane, farPlane);
         }
 
-        public void Build(RenderPipelineResources renderPipelinesResources, IBLFilterGGX iblFilterGGX)
+        public void Build(RenderPipelineResources renderPipelineResources, IBLFilterGGX iblFilterGGX)
-            m_StandardSkyboxMaterial = CoreUtils.CreateEngineMaterial(renderPipelinesResources.skyboxCubemap);
+            m_StandardSkyboxMaterial = CoreUtils.CreateEngineMaterial(renderPipelineResources.skyboxCubemap);
-            m_BlitCubemapMaterial = CoreUtils.CreateEngineMaterial(renderPipelinesResources.blitCubemap);
+            m_BlitCubemapMaterial = CoreUtils.CreateEngineMaterial(renderPipelineResources.blitCubemap);
-            m_OpaqueAtmScatteringMaterial = CoreUtils.CreateEngineMaterial(renderPipelinesResources.opaqueAtmosphericScattering);
+            m_OpaqueAtmScatteringMaterial = CoreUtils.CreateEngineMaterial(renderPipelineResources.opaqueAtmosphericScattering);
 
             m_CurrentUpdateTime = 0.0f;
         }

ScriptableRenderPipeline/HDRenderPipeline/package.json

 {
     "name": "com.unity.render-pipelines.high-definition",
     "description": "HD Render Pipeline for Unity.",
-    "version": "0.1.20",
+    "version": "0.1.21",
-        "com.unity.render-pipelines.core": "0.1.20"
+        "com.unity.render-pipelines.core": "0.1.21"
     }
 }

ScriptableRenderPipeline/LightweightPipeline/Data/LightweightPipelineAsset.cs

+#if UNITY_EDITOR
+using UnityEditor;
+using UnityEditor.ProjectWindowCallback;
+#endif
+
 namespace UnityEngine.Experimental.Rendering.LightweightPipeline
 {
     public enum ShadowCascades
 
     public class LightweightPipelineAsset : RenderPipelineAsset
     {
-        public static readonly string[] m_SearchPaths = {"Assets", "Packages/com.unity.render-pipelines"};
+        public static readonly string[] m_SearchPaths = {"Assets", "Packages/com.unity.render-pipelines.lightweight"};
 
         // Default values set when a new LightweightPipeline asset is created
         [SerializeField] private int m_MaxPixelLights = 4;
         [SerializeField] private Material m_DefaultParticleMaterial;
         [SerializeField] private Material m_DefaultTerrainMaterial;
 
-        [UnityEditor.MenuItem("Assets/Create/Render Pipeline/Lightweight/Pipeline Asset", priority = CoreUtils.assetCreateMenuPriority1)]
+        [MenuItem("Assets/Create/Render Pipeline/Lightweight/Pipeline Asset", priority = CoreUtils.assetCreateMenuPriority1)]
-            var instance = CreateInstance<LightweightPipelineAsset>();
+            ProjectWindowUtil.StartNameEditingIfProjectWindowExists(0, CreateInstance<CreateLightweightPipelineAsset>(),
+                "LightweightAsset.asset", null, null);
+        }
-            string[] guids = UnityEditor.AssetDatabase.FindAssets("LightweightPipelineResource t:scriptableobject", m_SearchPaths);
-            LightweightPipelineResource resourceAsset = null;
-            foreach (string guid in guids)
+        class CreateLightweightPipelineAsset : EndNameEditAction
+        {
+            public override void Action(int instanceId, string pathName, string resourceFile)
-                string path = UnityEditor.AssetDatabase.GUIDToAssetPath(guid);
-                resourceAsset = UnityEditor.AssetDatabase.LoadAssetAtPath<LightweightPipelineResource>(path);
-                if (resourceAsset != null)
-                    break;
-            }
+                var instance = CreateInstance<LightweightPipelineAsset>();
-            // There's currently an issue that prevents FindAssets from find resources withing the package folder.
-            if (resourceAsset == null)
-            {
-                string path = "Packages/com.unity.render-pipelines.lightweight/Data/LightweightPipelineResource.asset";
-                resourceAsset = UnityEditor.AssetDatabase.LoadAssetAtPath<LightweightPipelineResource>(path);
-            }
+                string[] guids = AssetDatabase.FindAssets("LightweightPipelineResource t:scriptableobject", m_SearchPaths);
+                LightweightPipelineResource resourceAsset = null;
+                foreach (string guid in guids)
+                {
+                    string path = AssetDatabase.GUIDToAssetPath(guid);
+                    resourceAsset = AssetDatabase.LoadAssetAtPath<LightweightPipelineResource>(path);
+                    if (resourceAsset != null)
+                        break;
+                }
-            if (resourceAsset != null)
-            {
-                instance.m_DefaultMaterial = resourceAsset.DefaultMaterial;
-                instance.m_DefaultParticleMaterial = resourceAsset.DefaultParticleMaterial;
-                instance.m_DefaultTerrainMaterial = resourceAsset.DefaultTerrainMaterial;
-            }
+                // There's currently an issue that prevents FindAssets from find resources withing the package folder.
+                if (resourceAsset == null)
+                {
+                    string path = "Packages/com.unity.render-pipelines.lightweight/Data/LightweightPipelineResource.asset";
+                    resourceAsset = AssetDatabase.LoadAssetAtPath<LightweightPipelineResource>(path);
+                }
-            instance.m_DefaultShader = Shader.Find(LightweightShaderUtils.GetShaderPath(ShaderPathID.STANDARD_PBS));
-            instance.m_BlitShader = Shader.Find(LightweightShaderUtils.GetShaderPath(ShaderPathID.HIDDEN_BLIT));
-            instance.m_CopyDepthShader = Shader.Find(LightweightShaderUtils.GetShaderPath(ShaderPathID.HIDDEN_DEPTH_COPY));
+                if (resourceAsset != null)
+                {
+                    instance.m_DefaultMaterial = resourceAsset.DefaultMaterial;
+                    instance.m_DefaultParticleMaterial = resourceAsset.DefaultParticleMaterial;
+                    instance.m_DefaultTerrainMaterial = resourceAsset.DefaultTerrainMaterial;
+                }
-            string assetPath = UnityEditor.EditorUtility.SaveFilePanelInProject("Save Lightweight Asset", "LightweightAsset", "asset",
-                    "Please enter a file name to save the asset to");
+                instance.m_DefaultShader = Shader.Find(LightweightShaderUtils.GetShaderPath(ShaderPathID.STANDARD_PBS));
+                instance.m_BlitShader = Shader.Find(LightweightShaderUtils.GetShaderPath(ShaderPathID.HIDDEN_BLIT));
+                instance.m_CopyDepthShader = Shader.Find(LightweightShaderUtils.GetShaderPath(ShaderPathID.HIDDEN_DEPTH_COPY));
-            if (assetPath.Length > 0)
-                UnityEditor.AssetDatabase.CreateAsset(instance, assetPath);
+                AssetDatabase.CreateAsset(instance, pathName);
+            }
-
 #endif
 
         protected override IRenderPipeline InternalCreatePipeline()

ScriptableRenderPipeline/LightweightPipeline/package.json

 {
     "name": "com.unity.render-pipelines.lightweight",
     "description": "Lightweight Render Pipeline for Unity.",
-    "version": "0.1.20",
+    "version": "0.1.21",
-        "com.unity.render-pipelines.core": "0.1.20"
+        "com.unity.render-pipelines.core": "0.1.21"
     }
 }

ScriptableRenderPipeline/master-package.json

 {
-    "version": "0.1.20",
+    "version": "0.1.21",
     "unity": "2018.1",
     "dependencies": {
         "com.unity.postprocessing": "0.1.7"

Tests/GraphicsTests/Framework/Editor/TestFramework.cs

 using System;
 using System.Collections;
+using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using NUnit.Framework;
 
         }
 
-		// collect the scenes that we can use
+        // Renderpipeline assets used for the tests
+        public static Dictionary<string, string> renderPipelineAssets = new Dictionary<string, string>()
+        {
+            { "HDRP", "HDRenderPipeline/CommonAssets/HDRP_GraphicTests_Asset.asset" },
+            { "LWRP", "LightweightPipeline/LightweightPipelineAsset.asset" }
+        };
+
+        // Renderpipeline assets used for the tests
+        public static Dictionary<string, string> renderPipelineScenesFolder = new Dictionary<string, string>()
+        {
+            { "HDRP", "HDRenderPipeline/Scenes" },
+            { "LWRP", "LightweightPipeline" }
+        };
+
+        // collect the scenes that we can use
-            public static IEnumerable HDScenes
+            public static IEnumerable HDRP
-                    return GetScenesForPipeline("HDRenderPipeline");
+                    return GetScenesForPipelineID("HDRP");
-            public static IEnumerable LWScenes
+            public static IEnumerable LWRP
-                    return GetScenesForPipeline("LightweightPipeline");
+                    return GetScenesForPipelineID("LWRP");
+            }
+
+            public static  IEnumerable GetScenesForPipelineID( string _pipelineID )
+            {
+                return GetScenesForPipeline( renderPipelineScenesFolder[_pipelineID] );
             }
 
             public static IEnumerable GetScenesForPipeline(string _pipelinePath)
                 var filesPath = Path.Combine(absoluteScenesPath, _pipelinePath);
 
                 // find all the scenes
-                var allPaths = System.IO.Directory.GetFiles(filesPath, "*.unity", System.IO.SearchOption.AllDirectories);
+                var allPaths = Directory.GetFiles(filesPath, "*.unity", SearchOption.AllDirectories);
+
+                // Convert to List for easy sorting in alphabetical ordre
+                List<string> allPaths_List = new List<string>(allPaths);
+                allPaths_List.Sort();
-                foreach (var path in allPaths)
+                for (int i=0; i<allPaths_List.Count; ++i)
+                    var path = allPaths_List[i];
+
                     var p = new FileInfo(path);
                     var split = s_Path.Aggregate("", Path.Combine);
                     split = string.Format("{0}{1}", split, Path.DirectorySeparatorChar);
             }
         }
 
-        [TearDown]
-        public void TearDown()
+
+        // Change the SRP before a full batch of tests
+        public virtual string _SRP_ID { get { return "NONE"; } }
+
+        [OneTimeSetUp]
+        public void OneTimeSetUp()
-            var testSetup = Object.FindObjectOfType<SetupSceneForRenderPipelineTest>();
-            if (testSetup == null)
-                return;
+            SetupRenderPipeAsset();
+        }
-            testSetup.TearDown();
+        [OneTimeTearDown]
+        public void OnTimeTearDown()
+        {
+            RestoreRenderPipeAsset();
-        [UnityTest]
-        public IEnumerator HDRP_TestScene([ValueSource(typeof(CollectScenes), "HDScenes")]TestInfo testInfo)
+        public static RenderPipelineAsset GetRenderPipelineAsset(string _SRP_ID)
-            return TestScene(testInfo);
+            string absolutePath = s_Path.Aggregate(s_RootPath, Path.Combine);
+
+            string filePath = Path.Combine(absolutePath, renderPipelineAssets[_SRP_ID] );
+
+            return (RenderPipelineAsset)AssetDatabase.LoadAssetAtPath(filePath, typeof(RenderPipelineAsset));
-        [UnityTest]
-        public IEnumerator LWRP_TestScene([ValueSource(typeof(CollectScenes), "LWScenes")]TestInfo testInfo)
+        public static RenderPipelineAsset beforeTestsRenderPipeAsset;
+        public static RenderPipelineAsset wantedTestsRenderPipeAsset;
+
+        public void SetupRenderPipeAsset()
-            return TestScene(testInfo);
+            Debug.Log("Set " + _SRP_ID + " render pipeline.");
+
+            beforeTestsRenderPipeAsset = UnityEngine.Rendering.GraphicsSettings.renderPipelineAsset;
+            wantedTestsRenderPipeAsset = GetRenderPipelineAsset(_SRP_ID);
+
+            if (wantedTestsRenderPipeAsset != beforeTestsRenderPipeAsset)
+                UnityEngine.Rendering.GraphicsSettings.renderPipelineAsset = wantedTestsRenderPipeAsset;
-        public IEnumerator TestScene(TestInfo testInfo)
+        public void RestoreRenderPipeAsset()
+        {
+            if (wantedTestsRenderPipeAsset != beforeTestsRenderPipeAsset)
+                UnityEngine.Rendering.GraphicsSettings.renderPipelineAsset = beforeTestsRenderPipeAsset;
+        }
+
+
+        // the actual test
+        public static IEnumerator TestScene(TestInfo testInfo)
         {
 			var prjRelativeGraphsPath = s_Path.Aggregate(s_RootPath, Path.Combine);
 			var filePath = Path.Combine(prjRelativeGraphsPath, testInfo.relativePath);
 
-            var testSetup = Object.FindObjectOfType<SetupSceneForRenderPipelineTest> ();
+            SetupSceneForRenderPipelineTest testSetup = Object.FindObjectOfType<SetupSceneForRenderPipelineTest> ();
 			Assert.IsNotNull(testSetup, "No SetupSceneForRenderPipelineTest in scene " + testInfo.name);
 			Assert.IsNotNull(testSetup.cameraToUse, "No configured camera in <SetupSceneForRenderPipelineTest>");
 
             }
 
 			Assert.IsTrue(areEqual, "Scene from {0}, did not match .template file.", testInfo.relativePath);
+
+            testSetup.TearDown();
-        private bool CompareTextures(Texture2D fromDisk, Texture2D captured, float threshold)
+        private static bool CompareTextures(Texture2D fromDisk, Texture2D captured, float threshold)
         {
             if (fromDisk == null || captured == null)
                 return false;
 			}
 			float rmse = Mathf.Sqrt(sumOfSquaredColorDistances / numberOfPixels);
 			return rmse < threshold;
+        }
+
+        // Graphic Tests Subclasses that inherit the functions bot provide different SRP_ID
+        public class HDRP : GraphicsTests
+        {
+            public override string _SRP_ID { get { return "HDRP"; } }
+
+            [UnityTest]
+            public IEnumerator HDRP_Test([ValueSource(typeof(CollectScenes), "HDRP")]TestInfo testInfo)
+            {
+                return TestScene(testInfo);
+            }
+        }
+
+        public class LTRP : GraphicsTests
+        {
+            public override string _SRP_ID { get { return "LWRP"; } }
+
+            [UnityTest]
+            public IEnumerator LWRP_Test([ValueSource(typeof(CollectScenes), "LWRP")]TestInfo testInfo)
+            {
+                return TestScene(testInfo);
+            }
         }
     }
 }

Tests/GraphicsTests/Framework/SetupSceneForRenderPipelineTest.cs

-using UnityEngine.Rendering;
+using UnityEngine.Rendering;
 
 namespace UnityEngine.Experimental.Rendering
 {
 		public void Setup()
 		{
 			m_OriginalAsset = GraphicsSettings.renderPipelineAsset;
-			GraphicsSettings.renderPipelineAsset = renderPipeline;
+            if (m_OriginalAsset != renderPipeline) GraphicsSettings.renderPipelineAsset = renderPipeline;
-			GraphicsSettings.renderPipelineAsset = m_OriginalAsset;
+			if ( GraphicsSettings.renderPipelineAsset != m_OriginalAsset ) GraphicsSettings.renderPipelineAsset = m_OriginalAsset;
 		}
 	}
 }

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/CommonAssets/HDRP_GraphicTests_Asset.asset

   m_Script: {fileID: 11500000, guid: 0cf1dab834d4ec34195b920ea7bbf9ec, type: 3}
   m_Name: HDRP_GraphicTests_Asset
   m_EditorClassIdentifier: 
-  m_RenderPipelineResources: {fileID: 11400000, guid: 42086e81f4f0c724f96f7f09cc995354,
+  m_RenderPipelineResources: {fileID: 11400000, guid: 3ce144cff5783da45aa5d4fdc2da14b7,
-  renderingSettings:
+  globalRenderingSettings:
-  sssSettings: {fileID: 11400000, guid: 873499ce7a6f749408981f512a9683f7, type: 2}
-  tileSettings:
+  globalTextureSettings:
+    spotCookieSize: 128
+    pointCookieSize: 512
+    reflectionCubemapSize: 128
+    reflectionCacheCompressed: 0
+  sssSettings: {fileID: 0}
+  lightLoopSettings:
-    enableClustered: 1
-    enableFptlForOpaqueWhenClustered: 1
+    enableFptlForForwardOpaque: 1
-    diffuseGlobalDimmer: 1
-    specularGlobalDimmer: 1
+    enableAsyncCompute: 0
-  textureSettings:
-    spotCookieSize: 128
-    pointCookieSize: 512
-    reflectionCubemapSize: 128
   m_DefaultDiffuseMaterial: {fileID: 2100000, guid: 73c176f402d2c2f4d929aa5da7585d17,
     type: 2}
   m_DefaultShader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/2xxx_Lighting/2001_Dynamic_Directional.unity

   - component: {fileID: 835557364}
   - component: {fileID: 835557363}
   - component: {fileID: 835557362}
-  - component: {fileID: 835557361}
   m_Layer: 0
   m_Name: Capsule
   m_TagString: Untagged
   m_IsActive: 1
---- !u!136 &835557361
-CapsuleCollider:
-  m_ObjectHideFlags: 0
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 0}
-  m_GameObject: {fileID: 835557360}
-  m_Material: {fileID: 0}
-  m_IsTrigger: 0
-  m_Enabled: 1
-  m_Radius: 0.5
-  m_Height: 2
-  m_Direction: 1
-  m_Center: {x: 0, y: 0, z: 0}
 --- !u!23 &835557362
 MeshRenderer:
   m_ObjectHideFlags: 0
   m_Children: []
   m_Father: {fileID: 0}
   m_RootOrder: 3
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!1001 &1134522063
+Prefab:
+  m_ObjectHideFlags: 0
+  serializedVersion: 2
+  m_Modification:
+    m_TransformParent: {fileID: 0}
+    m_Modifications:
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_LocalPosition.x
+      value: -0.113
+      objectReference: {fileID: 0}
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_LocalPosition.y
+      value: 0.08
+      objectReference: {fileID: 0}
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_LocalPosition.z
+      value: -1.511
+      objectReference: {fileID: 0}
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_LocalRotation.x
+      value: -0
+      objectReference: {fileID: 0}
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_LocalRotation.y
+      value: -0.25287157
+      objectReference: {fileID: 0}
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_LocalRotation.z
+      value: -0
+      objectReference: {fileID: 0}
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_LocalRotation.w
+      value: 0.96749985
+      objectReference: {fileID: 0}
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_RootOrder
+      value: 5
+      objectReference: {fileID: 0}
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_LocalScale.x
+      value: 4.4106
+      objectReference: {fileID: 0}
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_LocalScale.y
+      value: 0.3
+      objectReference: {fileID: 0}
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_LocalScale.z
+      value: 0.3
+      objectReference: {fileID: 0}
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_LocalEulerAnglesHint.y
+      value: -29.295002
+      objectReference: {fileID: 0}
+    m_RemovedComponents: []
+  m_ParentPrefab: {fileID: 100100000, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+  m_IsPrefabParent: 0
+--- !u!1 &1669536974
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 1669536978}
+  - component: {fileID: 1669536977}
+  - component: {fileID: 1669536976}
+  m_Layer: 0
+  m_Name: Capsule (1)
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!23 &1669536976
+MeshRenderer:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1669536974}
+  m_Enabled: 1
+  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
+  m_MotionVectors: 1
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_RenderingLayerMask: 4294967295
+  m_Materials:
+  - {fileID: 2100000, guid: 2505e1d9c7a8c654487d6a2dcae04242, type: 2}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_PreserveUVs: 0
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
+  m_SelectedEditorRenderState: 3
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0
+--- !u!33 &1669536977
+MeshFilter:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1669536974}
+  m_Mesh: {fileID: 10208, guid: 0000000000000000e000000000000000, type: 0}
+--- !u!4 &1669536978
+Transform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1669536974}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: -2.13, y: -2, z: -1.02}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 4
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
 --- !u!1 &1900725046
 GameObject:

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/2xxx_Lighting/2002_Dynamic_Mix.unity

     debug:
       m_Flags: 0
   m_NavMeshData: {fileID: 0}
+--- !u!1001 &183745593
+Prefab:
+  m_ObjectHideFlags: 0
+  serializedVersion: 2
+  m_Modification:
+    m_TransformParent: {fileID: 737838453}
+    m_Modifications:
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_LocalPosition.x
+      value: 0.100000024
+      objectReference: {fileID: 0}
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_LocalPosition.y
+      value: 1.817
+      objectReference: {fileID: 0}
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_LocalPosition.z
+      value: -0.923
+      objectReference: {fileID: 0}
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_LocalRotation.x
+      value: -0
+      objectReference: {fileID: 0}
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_LocalRotation.y
+      value: -0.33849397
+      objectReference: {fileID: 0}
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_LocalRotation.z
+      value: -0
+      objectReference: {fileID: 0}
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_LocalRotation.w
+      value: 0.9409686
+      objectReference: {fileID: 0}
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_RootOrder
+      value: 3
+      objectReference: {fileID: 0}
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_LocalScale.x
+      value: 2
+      objectReference: {fileID: 0}
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_LocalScale.y
+      value: 0.3
+      objectReference: {fileID: 0}
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_LocalScale.z
+      value: 0.3
+      objectReference: {fileID: 0}
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_LocalEulerAnglesHint.y
+      value: -39.570004
+      objectReference: {fileID: 0}
+    m_RemovedComponents: []
+  m_ParentPrefab: {fileID: 100100000, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+  m_IsPrefabParent: 0
+--- !u!4 &183745594 stripped
+Transform:
+  m_PrefabParentObject: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23,
+    type: 2}
+  m_PrefabInternal: {fileID: 183745593}
+--- !u!1001 &333183857
+Prefab:
+  m_ObjectHideFlags: 0
+  serializedVersion: 2
+  m_Modification:
+    m_TransformParent: {fileID: 1192666584}
+    m_Modifications:
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_LocalPosition.x
+      value: 0.03999996
+      objectReference: {fileID: 0}
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_LocalPosition.y
+      value: 1.817
+      objectReference: {fileID: 0}
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_LocalPosition.z
+      value: -0.99
+      objectReference: {fileID: 0}
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_LocalRotation.x
+      value: -0
+      objectReference: {fileID: 0}
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_LocalRotation.y
+      value: -0.34168717
+      objectReference: {fileID: 0}
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_LocalRotation.z
+      value: -0
+      objectReference: {fileID: 0}
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_LocalRotation.w
+      value: 0.93981373
+      objectReference: {fileID: 0}
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_RootOrder
+      value: 3
+      objectReference: {fileID: 0}
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_LocalScale.x
+      value: 2
+      objectReference: {fileID: 0}
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_LocalScale.y
+      value: 0.3
+      objectReference: {fileID: 0}
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_LocalScale.z
+      value: 0.3
+      objectReference: {fileID: 0}
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_LocalEulerAnglesHint.y
+      value: -39.959003
+      objectReference: {fileID: 0}
+    - target: {fileID: 1752614318191108, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_Name
+      value: Cube (2)
+      objectReference: {fileID: 0}
+    m_RemovedComponents: []
+  m_ParentPrefab: {fileID: 100100000, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+  m_IsPrefabParent: 0
+--- !u!4 &333183858 stripped
+Transform:
+  m_PrefabParentObject: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23,
+    type: 2}
+  m_PrefabInternal: {fileID: 333183857}
 --- !u!1 &467207848
 GameObject:
   m_ObjectHideFlags: 0
   - {fileID: 1890834151}
   - {fileID: 626316075}
   m_Father: {fileID: 0}
-  m_RootOrder: 3
+  m_RootOrder: 2
+--- !u!1001 &607344269
+Prefab:
+  m_ObjectHideFlags: 0
+  serializedVersion: 2
+  m_Modification:
+    m_TransformParent: {fileID: 1902903443}
+    m_Modifications:
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_LocalPosition.x
+      value: 0.427
+      objectReference: {fileID: 0}
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_LocalPosition.y
+      value: 1.501
+      objectReference: {fileID: 0}
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_LocalPosition.z
+      value: 0.6890001
+      objectReference: {fileID: 0}
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_LocalRotation.x
+      value: -0
+      objectReference: {fileID: 0}
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_LocalRotation.y
+      value: 0.41579127
+      objectReference: {fileID: 0}
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_LocalRotation.z
+      value: -0
+      objectReference: {fileID: 0}
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_LocalRotation.w
+      value: 0.90946007
+      objectReference: {fileID: 0}
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_RootOrder
+      value: 4
+      objectReference: {fileID: 0}
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_LocalScale.x
+      value: 2
+      objectReference: {fileID: 0}
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_LocalScale.y
+      value: 0.3
+      objectReference: {fileID: 0}
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_LocalScale.z
+      value: 0.3
+      objectReference: {fileID: 0}
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_LocalEulerAnglesHint.y
+      value: 49.138
+      objectReference: {fileID: 0}
+    - target: {fileID: 1752614318191108, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_Name
+      value: Cube (3)
+      objectReference: {fileID: 0}
+    m_RemovedComponents: []
+  m_ParentPrefab: {fileID: 100100000, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+  m_IsPrefabParent: 0
+--- !u!4 &607344270 stripped
+Transform:
+  m_PrefabParentObject: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23,
+    type: 2}
+  m_PrefabInternal: {fileID: 607344269}
 --- !u!1 &626316074
 GameObject:
   m_ObjectHideFlags: 0
   m_Children:
   - {fileID: 1028431635}
   - {fileID: 1169686270}
+  - {fileID: 2138720844}
+  - {fileID: 183745594}
+--- !u!1001 &809663470
+Prefab:
+  m_ObjectHideFlags: 0
+  serializedVersion: 2
+  m_Modification:
+    m_TransformParent: {fileID: 2109923720}
+    m_Modifications:
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_LocalPosition.x
+      value: 0.15299988
+      objectReference: {fileID: 0}
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_LocalPosition.y
+      value: 1.817
+      objectReference: {fileID: 0}
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_LocalPosition.z
+      value: -0.80200005
+      objectReference: {fileID: 0}
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_LocalRotation.x
+      value: -0
+      objectReference: {fileID: 0}
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_LocalRotation.y
+      value: -0.27791908
+      objectReference: {fileID: 0}
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_LocalRotation.z
+      value: -0
+      objectReference: {fileID: 0}
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_LocalRotation.w
+      value: 0.96060455
+      objectReference: {fileID: 0}
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_RootOrder
+      value: 3
+      objectReference: {fileID: 0}
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_LocalScale.x
+      value: 2
+      objectReference: {fileID: 0}
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_LocalScale.y
+      value: 0.3
+      objectReference: {fileID: 0}
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_LocalScale.z
+      value: 0.3
+      objectReference: {fileID: 0}
+    - target: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_LocalEulerAnglesHint.y
+      value: -32.272003
+      objectReference: {fileID: 0}
+    - target: {fileID: 1752614318191108, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+      propertyPath: m_Name
+      value: Cube (1)
+      objectReference: {fileID: 0}
+    m_RemovedComponents: []
+  m_ParentPrefab: {fileID: 100100000, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23, type: 2}
+  m_IsPrefabParent: 0
+--- !u!4 &809663471 stripped
+Transform:
+  m_PrefabParentObject: {fileID: 4729046375724384, guid: 48a8bf1cfd4090647aa6cdcd4cddfc23,
+    type: 2}
+  m_PrefabInternal: {fileID: 809663470}
 --- !u!1 &835557360
 GameObject:
   m_ObjectHideFlags: 0
   m_Children:
   - {fileID: 1498382502}
   - {fileID: 673842479}
+  - {fileID: 1753161994}
+  - {fileID: 333183858}
   m_Father: {fileID: 0}
   m_RootOrder: 6
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
   m_Father: {fileID: 1192666584}
   m_RootOrder: 0
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!1 &1556403009
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 1556403010}
+  - component: {fileID: 1556403013}
+  - component: {fileID: 1556403012}
+  - component: {fileID: 1556403011}
+  m_Layer: 0
+  m_Name: Capsule (1)
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &1556403010
+Transform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1556403009}
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: -0.93, y: 1, z: -0.58}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 2109923720}
+  m_RootOrder: 2
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!136 &1556403011
+CapsuleCollider:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1556403009}
+  m_Material: {fileID: 0}
+  m_IsTrigger: 0
+  m_Enabled: 1
+  m_Radius: 0.5
+  m_Height: 2
+  m_Direction: 1
+  m_Center: {x: 0, y: 0, z: 0}
+--- !u!23 &1556403012
+MeshRenderer:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1556403009}
+  m_Enabled: 1
+  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
+  m_MotionVectors: 1
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_RenderingLayerMask: 4294967295
+  m_Materials:
+  - {fileID: 2100000, guid: 2505e1d9c7a8c654487d6a2dcae04242, type: 2}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_PreserveUVs: 0
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
+  m_SelectedEditorRenderState: 3
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0
+--- !u!33 &1556403013
+MeshFilter:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1556403009}
+  m_Mesh: {fileID: 10208, guid: 0000000000000000e000000000000000, type: 0}
 --- !u!1 &1637281119
 GameObject:
   m_ObjectHideFlags: 0
   m_UseColorTemperature: 0
   m_ShadowRadius: 0
   m_ShadowAngle: 0
+--- !u!1 &1660772714
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 1660772715}
+  - component: {fileID: 1660772718}
+  - component: {fileID: 1660772717}
+  - component: {fileID: 1660772716}
+  m_Layer: 0
+  m_Name: Capsule (4)
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &1660772715
+Transform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1660772714}
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: 0.69299984, y: 1, z: 2.0500002}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 1902903443}
+  m_RootOrder: 3
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!136 &1660772716
+CapsuleCollider:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1660772714}
+  m_Material: {fileID: 0}
+  m_IsTrigger: 0
+  m_Enabled: 1
+  m_Radius: 0.5
+  m_Height: 2
+  m_Direction: 1
+  m_Center: {x: 0, y: 0, z: 0}
+--- !u!23 &1660772717
+MeshRenderer:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1660772714}
+  m_Enabled: 1
+  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
+  m_MotionVectors: 1
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_RenderingLayerMask: 4294967295
+  m_Materials:
+  - {fileID: 2100000, guid: 2505e1d9c7a8c654487d6a2dcae04242, type: 2}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_PreserveUVs: 0
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
+  m_SelectedEditorRenderState: 3
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0
+--- !u!33 &1660772718
+MeshFilter:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1660772714}
+  m_Mesh: {fileID: 10208, guid: 0000000000000000e000000000000000, type: 0}
+--- !u!1 &1753161993
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 1753161994}
+  - component: {fileID: 1753161997}
+  - component: {fileID: 1753161996}
+  - component: {fileID: 1753161995}
+  m_Layer: 0
+  m_Name: Capsule (3)
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &1753161994
+Transform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1753161993}
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: -0.86000013, y: 1, z: -0.72}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 1192666584}
+  m_RootOrder: 2
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!136 &1753161995
+CapsuleCollider:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1753161993}
+  m_Material: {fileID: 0}
+  m_IsTrigger: 0
+  m_Enabled: 1
+  m_Radius: 0.5
+  m_Height: 2
+  m_Direction: 1
+  m_Center: {x: 0, y: 0, z: 0}
+--- !u!23 &1753161996
+MeshRenderer:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1753161993}
+  m_Enabled: 1
+  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
+  m_MotionVectors: 1
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_RenderingLayerMask: 4294967295
+  m_Materials:
+  - {fileID: 2100000, guid: 2505e1d9c7a8c654487d6a2dcae04242, type: 2}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_PreserveUVs: 0
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
+  m_SelectedEditorRenderState: 3
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0
+--- !u!33 &1753161997
+MeshFilter:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1753161993}
+  m_Mesh: {fileID: 10208, guid: 0000000000000000e000000000000000, type: 0}
 --- !u!1 &1837398465
 GameObject:
   m_ObjectHideFlags: 0
   - {fileID: 1302673723}
   - {fileID: 1837398469}
   - {fileID: 467207852}
+  - {fileID: 1660772715}
+  - {fileID: 607344270}
-  m_RootOrder: 2
+  m_RootOrder: 3
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
 --- !u!1 &1930668412
 GameObject:
   m_Children:
   - {fileID: 835557364}
   - {fileID: 956017065}
+  - {fileID: 1556403010}
+  - {fileID: 809663471}
+--- !u!1 &2138720843
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 2138720844}
+  - component: {fileID: 2138720847}
+  - component: {fileID: 2138720846}
+  - component: {fileID: 2138720845}
+  m_Layer: 0
+  m_Name: Capsule (2)
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &2138720844
+Transform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 2138720843}
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: -0.8699999, y: 1, z: -0.62}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 737838453}
+  m_RootOrder: 2
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!136 &2138720845
+CapsuleCollider:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 2138720843}
+  m_Material: {fileID: 0}
+  m_IsTrigger: 0
+  m_Enabled: 1
+  m_Radius: 0.5
+  m_Height: 2
+  m_Direction: 1
+  m_Center: {x: 0, y: 0, z: 0}
+--- !u!23 &2138720846
+MeshRenderer:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 2138720843}
+  m_Enabled: 1
+  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
+  m_MotionVectors: 1
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_RenderingLayerMask: 4294967295
+  m_Materials:
+  - {fileID: 2100000, guid: 2505e1d9c7a8c654487d6a2dcae04242, type: 2}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_PreserveUVs: 0
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
+  m_SelectedEditorRenderState: 3
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0
+--- !u!33 &2138720847
+MeshFilter:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 2138720843}
+  m_Mesh: {fileID: 10208, guid: 0000000000000000e000000000000000, type: 0}

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/2xxx_Lighting/2003_Light_Parameters.unity

   m_ReflectionIntensity: 1
   m_CustomReflection: {fileID: 0}
   m_Sun: {fileID: 0}
-  m_IndirectSpecularColor: {r: 0.3661533, g: 0.3847445, b: 0.42534745, a: 1}
+  m_IndirectSpecularColor: {r: 0.07321051, g: 0.076927215, b: 0.08504366, a: 1}
   m_UseRadianceAmbientProbe: 0
 --- !u!157 &3
 LightmapSettings:
   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_GameObject: {fileID: 119984175}
-  m_LocalRotation: {x: -0, y: -0, z: 0.70710677, w: 0.7071068}
-  m_LocalPosition: {x: -2.429, y: -0.5, z: 0}
+  m_LocalRotation: {x: 0.059106357, y: -0.05910636, z: 0.7046321, w: 0.7046322}
+  m_LocalPosition: {x: -2.429, y: -2.11, z: -0.4}
-  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 90.00001}
+  m_LocalEulerAnglesHint: {x: 9.59, y: 0, z: 90.00001}
 --- !u!102 &119984177
 TextMesh:
   serializedVersion: 3
   m_GameObject: {fileID: 119984175}
-  m_Text: Spot Point
+  m_Text: ' Line  Rect. Spot Point'
-  m_CharacterSize: 0.2
+  m_CharacterSize: 0.15
   m_LineSpacing: 1
   m_Anchor: 7
   m_Alignment: 1
   serializedVersion: 8
   m_Type: 2
   m_Color: {r: 1, g: 1, b: 1, a: 1}
-  m_Intensity: 3.14
+  m_Intensity: 1
   m_Range: 0.6
   m_SpotAngle: 140
   m_CookieSize: 10
   serializedVersion: 8
   m_Type: 2
   m_Color: {r: 1, g: 1, b: 1, a: 1}
-  m_Intensity: 3.14
+  m_Intensity: 1
   m_Range: 0.6
   m_SpotAngle: 140
   m_CookieSize: 10
   m_Type: 2
   m_Color: {r: 1, g: 1, b: 1, a: 1}
   m_Intensity: 1
-  m_Range: 0.6
+  m_Range: 0.8
   m_SpotAngle: 140
   m_CookieSize: 10
   m_Shadows:
   m_Type: 2
   m_Color: {r: 1, g: 1, b: 1, a: 1}
   m_Intensity: 1
-  m_Range: 0.7
+  m_Range: 0.8
   m_SpotAngle: 30
   m_CookieSize: 10
   m_Shadows:
   m_Type: 2
   m_Color: {r: 1, g: 1, b: 1, a: 1}
   m_Intensity: 1
-  m_Range: 0.7
+  m_Range: 0.8
   m_SpotAngle: 30
   m_CookieSize: 10
   m_Shadows:
   m_Type: 2
   m_Color: {r: 1, g: 1, b: 1, a: 1}
   m_Intensity: 1
-  m_Range: 0.6
+  m_Range: 0.8
   m_SpotAngle: 140
   m_CookieSize: 10
   m_Shadows:
   m_Type: 2
   m_Color: {r: 1, g: 1, b: 1, a: 1}
   m_Intensity: 1
-  m_Range: 0.6
+  m_Range: 0.8
   m_SpotAngle: 140
   m_CookieSize: 10
   m_Shadows:
   m_Type: 2
   m_Color: {r: 1, g: 1, b: 1, a: 1}
   m_Intensity: 1
-  m_Range: 0.7
+  m_Range: 0.8
   m_SpotAngle: 179
   m_CookieSize: 10
   m_Shadows:
   m_Type: 0
   m_Color: {r: 1, g: 1, b: 1, a: 1}
   m_Intensity: 1
-  m_Range: 0.6
+  m_Range: 0.7
   m_SpotAngle: 179
   m_CookieSize: 10
   m_Shadows:
       value: 
       objectReference: {fileID: 11400000, guid: 6afe60f7be788644f84fb8dc55566ff7,
         type: 2}
+    - target: {fileID: 114110876577682668, guid: c07ace9ab142ca9469fa377877c2f1e7,
+        type: 2}
+      propertyPath: m_Enabled
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 20109210616973140, guid: c07ace9ab142ca9469fa377877c2f1e7,
+        type: 2}
+      propertyPath: m_BackGroundColor.r
+      value: 0.2509804
+      objectReference: {fileID: 0}
+    - target: {fileID: 20109210616973140, guid: c07ace9ab142ca9469fa377877c2f1e7,
+        type: 2}
+      propertyPath: m_BackGroundColor.g
+      value: 0.2509804
+      objectReference: {fileID: 0}
+    - target: {fileID: 20109210616973140, guid: c07ace9ab142ca9469fa377877c2f1e7,
+        type: 2}
+      propertyPath: m_BackGroundColor.b
+      value: 0.2509804
+      objectReference: {fileID: 0}
     m_RemovedComponents: []
   m_ParentPrefab: {fileID: 100100000, guid: c07ace9ab142ca9469fa377877c2f1e7, type: 2}
   m_IsPrefabParent: 0
   m_Type: 0
   m_Color: {r: 1, g: 1, b: 1, a: 1}
   m_Intensity: 1
-  m_Range: 0.6
+  m_Range: 0.7
   m_SpotAngle: 179
   m_CookieSize: 10
   m_Shadows:
   m_Type: 0
   m_Color: {r: 1, g: 1, b: 1, a: 1}
   m_Intensity: 1
-  m_Range: 0.6
+  m_Range: 0.7
   m_SpotAngle: 179
   m_CookieSize: 10
   m_Shadows:
   serializedVersion: 8
   m_Type: 2
   m_Color: {r: 1, g: 1, b: 1, a: 1}
-  m_Intensity: 3.14
+  m_Intensity: 1
   m_Range: 0.6
   m_SpotAngle: 140
   m_CookieSize: 10

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/2xxx_Lighting/2003_Light_Parameters/HDRP_Default_Sky 1.asset

   m_EditorClassIdentifier: 
   rotation: 160
   exposure: 0
-  multiplier: 1
+  multiplier: 0.2
   resolution: 256
   updateMode: 0
   updatePeriod: 0

ScriptableRenderPipeline/Core/ShaderLibrary/Sampling/SampleUVMapping.hlsl

 // This structure abstract uv mapping inside one struct.
 // It represent a mapping of any uv (with its associated tangent space for derivative if SurfaceGradient mode) - UVSet0 to 4, planar, triplanar
 
-#include "NormalSurfaceGradient.hlsl"
+#include "../NormalSurfaceGradient.hlsl"
 
 #define UV_MAPPING_UVSET 0
 #define UV_MAPPING_PLANAR 1

ScriptableRenderPipeline/HDRenderPipeline/RenderPipelineResources/CopyStencilBuffer.shader

 
     #include "ShaderLibrary/Common.hlsl"
     #include "ShaderLibrary/Packing.hlsl"
-    #include "../../../ShaderVariables.hlsl"
-    #include "../../../Lighting/LightDefinition.cs.hlsl"
+    #include "../ShaderVariables.hlsl"
+    #include "../Lighting/LightDefinition.cs.hlsl"
 
     int _StencilRef;
     RW_TEXTURE2D(float, _HTile); // DXGI_FORMAT_R8_UINT is not supported by Unity

ScriptableRenderPipeline/HDRenderPipeline/Material/SubsurfaceScattering/SubsurfaceScattering.shader

             #pragma multi_compile _ SSS_FILTER_HORIZONTAL_AND_COMBINE
 
             // Do not modify these.
-            #include "../../../ShaderPass/ShaderPass.cs.hlsl"
+            #include "../../ShaderPass/ShaderPass.cs.hlsl"
             #define SHADERPASS SHADERPASS_SUBSURFACE_SCATTERING
 
             //-------------------------------------------------------------------------------------
             #include "ShaderLibrary/Common.hlsl"
-            #include "../../../ShaderVariables.hlsl"
-            #include "../../SubsurfaceScattering/SubsurfaceScattering.hlsl"
+            #include "../../ShaderVariables.hlsl"
+            #include "SubsurfaceScattering.hlsl"
 
             //-------------------------------------------------------------------------------------
             // Inputs & outputs

ScriptableRenderPipeline/HDRenderPipeline/Material/SubsurfaceScattering/SubsurfaceScattering.compute

 #define SSS_DEBUG_NORMAL_VS   0
 
 // Do not modify these.
-#include "../../../ShaderPass/ShaderPass.cs.hlsl"
+#include "../../ShaderPass/ShaderPass.cs.hlsl"
 #define SHADERPASS            SHADERPASS_SUBSURFACE_SCATTERING
 #define GROUP_SIZE_1D         16
 #define GROUP_SIZE_2D         (GROUP_SIZE_1D * GROUP_SIZE_1D)
 
 #include "ShaderLibrary/Common.hlsl"
 #include "ShaderLibrary/Packing.hlsl"
-#include "ShaderLibrary\Fibonacci.hlsl"
+#include "ShaderLibrary/Sampling/Fibonacci.hlsl"
-#include "../../../ShaderVariables.hlsl"
-#include "../../../Lighting/LightDefinition.cs.hlsl"
-#include "../../SubsurfaceScattering/SubsurfaceScattering.hlsl"
+#include "../../ShaderVariables.hlsl"
+#include "../../Lighting/LightDefinition.cs.hlsl"
+#include "SubsurfaceScattering.hlsl"
 
 //--------------------------------------------------------------------------------------------------
 // Inputs & outputs
 
 TEXTURE2D(_DepthTexture);                           // Z-buffer
-TEXTURE2D(_HTile);                                  // DXGI_FORMAT_R8_UINT is not supported by Unity
+TEXTURE2D(_SSSHTile);                                  // DXGI_FORMAT_R8_UINT is not supported by Unity
 TEXTURE2D(_IrradianceSource);                       // Includes transmitted light
 
 #ifdef USE_INTERMEDIATE_BUFFER
         float stencilRef = STENCILLIGHTINGUSAGE_SPLIT_LIGHTING;
 
         // Check whether the thread group needs to perform any work.
-        float s00 = LOAD_TEXTURE2D(_HTile, 2 * groupId + uint2(0, 0)).r;
-        float s10 = LOAD_TEXTURE2D(_HTile, 2 * groupId + uint2(1, 0)).r;
-        float s01 = LOAD_TEXTURE2D(_HTile, 2 * groupId + uint2(0, 1)).r;
-        float s11 = LOAD_TEXTURE2D(_HTile, 2 * groupId + uint2(1, 1)).r;
+        float s00 = LOAD_TEXTURE2D(_SSSHTile, 2 * groupId + uint2(0, 0)).r;
+        float s10 = LOAD_TEXTURE2D(_SSSHTile, 2 * groupId + uint2(1, 0)).r;
+        float s01 = LOAD_TEXTURE2D(_SSSHTile, 2 * groupId + uint2(0, 1)).r;
+        float s11 = LOAD_TEXTURE2D(_SSSHTile, 2 * groupId + uint2(1, 1)).r;
 
         // Perform the stencil test (reject at the tile rate).
         processGroup = (stencilRef == s00 || stencilRef == s10 || stencilRef == s01 || stencilRef == s11);

ScriptableRenderPipeline/Core/Editor/FilterWindow.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using UnityEngine;
+
+namespace UnityEditor.Experimental.Rendering
+{
+    [InitializeOnLoad]
+    public class FilterWindow : EditorWindow
+    {
+        public interface IProvider
+        {
+            Vector2 position { get; set; }
+
+            void CreateComponentTree(List<Element> tree);
+            bool GoToChild(Element element, bool addIfComponent);
+        }
+
+        public static readonly float DefaultWidth = 250f;
+        public static readonly float DefaultHeight = 300f;
+
+        #region BaseElements
+
+        public class Element : IComparable
+        {
+            public int level;
+            public GUIContent content;
+
+            public string name
+            {
+                get { return content.text; }
+            }
+
+            public int CompareTo(object o)
+            {
+                return name.CompareTo((o as Element).name);
+            }
+        }
+
+        [Serializable]
+        public class GroupElement : Element
+        {
+            public Vector2 scroll;
+            public int selectedIndex;
+
+            public bool WantsFocus { get; protected set; }
+
+            public virtual bool ShouldDisable
+            {
+                get { return false; }
+            }
+
+            public GroupElement(int level, string name)
+            {
+                this.level = level;
+                content = new GUIContent(name);
+            }
+
+            public virtual bool HandleKeyboard(Event evt, FilterWindow window, Action goToParent)
+            {
+                return false;
+            }
+
+            public virtual bool OnGUI(FilterWindow sFilterWindow)
+            {
+                return false;
+            }
+        }
+
+        #endregion
+
+        // Styles
+
+        class Styles
+        {
+            public GUIStyle header = (GUIStyle)typeof(EditorStyles).GetProperty("inspectorBig", BindingFlags.Static | BindingFlags.NonPublic).GetValue(null, null);
+            public GUIStyle componentButton = new GUIStyle("PR Label");
+            public GUIStyle groupButton;
+            public GUIStyle background = "grey_border";
+            public GUIStyle rightArrow = "AC RightArrow";
+            public GUIStyle leftArrow = "AC LeftArrow";
+
+            public Styles()
+            {
+                header.font = EditorStyles.boldLabel.font;
+
+                componentButton.alignment = TextAnchor.MiddleLeft;
+                componentButton.fixedHeight = 20;
+                componentButton.imagePosition = ImagePosition.ImageAbove;
+
+                groupButton = new GUIStyle(componentButton);
+            }
+        }
+
+        const int k_HeaderHeight = 30;
+        const int k_WindowHeight = 400 - 80;
+        const int k_HelpHeight = 80 * 0;
+        const string k_ComponentSearch = "NodeSearchString";
+
+        static Styles s_Styles;
+        static FilterWindow s_FilterWindow;
+        static long s_LastClosedTime;
+        static bool s_DirtyList;
+
+        IProvider m_Provider;
+        Element[] m_Tree;
+        Element[] m_SearchResultTree;
+        List<GroupElement> m_Stack = new List<GroupElement>();
+
+        float m_Anim = 1;
+        int m_AnimTarget = 1;
+        long m_LastTime;
+        bool m_ScrollToSelected;
+        string m_DelayedSearch;
+        string m_Search = "";
+
+        bool m_HasSearch { get { return !string.IsNullOrEmpty(m_Search); } }
+        GroupElement m_ActiveParent { get { return m_Stack[m_Stack.Count - 2 + m_AnimTarget]; } }
+        Element[] m_ActiveTree { get { return m_HasSearch ? m_SearchResultTree : m_Tree; } }
+        Element m_ActiveElement
+        {
+            get
+            {
+                if (m_ActiveTree == null)
+                    return null;
+
+                var children = GetChildren(m_ActiveTree, m_ActiveParent);
+                return children.Count == 0
+                    ? null
+                    : children[m_ActiveParent.selectedIndex];
+            }
+        }
+        bool m_IsAnimating { get { return !Mathf.Approximately(m_Anim, m_AnimTarget); } }
+
+        static FilterWindow()
+        {
+            s_DirtyList = true;
+        }
+
+        void OnEnable()
+        {
+            s_FilterWindow = this;
+            m_Search = "";
+        }
+
+        void OnDisable()
+        {
+            s_LastClosedTime = DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond;
+            s_FilterWindow = null;
+        }
+
+        internal static bool ValidateAddComponentMenuItem()
+        {
+            return true;
+        }
+
+        internal static bool Show(Vector2 position, IProvider provider)
+        {
+            // If the window is already open, close it instead.
+            var wins = Resources.FindObjectsOfTypeAll(typeof(FilterWindow));
+            if (wins.Length > 0)
+            {
+                try
+                {
+                    ((EditorWindow)wins[0]).Close();
+                    return false;
+                }
+                catch (Exception)
+                {
+                    s_FilterWindow = null;
+                }
+            }
+
+            // We could not use realtimeSinceStartUp since it is set to 0 when entering/exitting
+            // playmode, we assume an increasing time when comparing time.
+            long nowMilliSeconds = DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond;
+            bool justClosed = nowMilliSeconds < s_LastClosedTime + 50;
+
+            if (!justClosed)
+            {
+                Event.current.Use();
+
+                if (s_FilterWindow == null)
+                {
+                    s_FilterWindow = CreateInstance<FilterWindow>();
+                    s_FilterWindow.hideFlags = HideFlags.HideAndDontSave;
+                }
+
+                s_FilterWindow.Init(position, provider);
+                return true;
+            }
+            return false;
+        }
+
+        static object Invoke(Type t, object inst, string method, params object[] args)
+        {
+            var flags = (inst == null ? BindingFlags.Static : BindingFlags.Instance) | BindingFlags.NonPublic;
+            var mi = t.GetMethod(method, flags);
+            return mi.Invoke(inst, args);
+        }
+
+        void Init(Vector2 position, IProvider provider)
+        {
+            m_Provider = provider;
+            // Has to be done before calling Show / ShowWithMode
+            m_Provider.position = position;
+            position = GUIUtility.GUIToScreenPoint(position);
+            var buttonRect = new Rect(position.x - DefaultWidth / 2, position.y - 16, DefaultWidth, 1);
+
+            CreateComponentTree();
+
+            ShowAsDropDown(buttonRect, new Vector2(buttonRect.width, k_WindowHeight));
+
+            Focus();
+
+            wantsMouseMove = true;
+        }
+
+        void CreateComponentTree()
+        {
+            var tree = new List<Element>();
+            m_Provider.CreateComponentTree(tree);
+
+            m_Tree = tree.ToArray();
+
+            // Rebuild stack
+            if (m_Stack.Count == 0)
+            {
+                m_Stack.Add(m_Tree[0] as GroupElement);
+            }
+            else
+            {
+                // The root is always the match for level 0
+                var match = m_Tree[0] as GroupElement;
+                int level = 0;
+                while (true)
+                {
+                    // Assign the match for the current level
+                    var oldElement = m_Stack[level];
+                    m_Stack[level] = match;
+                    m_Stack[level].selectedIndex = oldElement.selectedIndex;
+                    m_Stack[level].scroll = oldElement.scroll;
+
+                    // See if we reached last element of stack
+                    level++;
+                    if (level == m_Stack.Count)
+                        break;
+
+                    // Try to find a child of the same name as we had before
+                    var children = GetChildren(m_ActiveTree, match);
+                    var childMatch = children.FirstOrDefault(c => c.name == m_Stack[level].name);
+
+                    if (childMatch is GroupElement)
+                    {
+                        match = childMatch as GroupElement;
+                    }
+                    else
+                    {
+                        // If we couldn't find the child, remove all further elements from the stack
+                        while (m_Stack.Count > level)
+                            m_Stack.RemoveAt(level);
+                    }
+                }
+            }
+
+            s_DirtyList = false;
+            RebuildSearch();
+        }
+
+        internal void OnGUI()
+        {
+            if (s_Styles == null)
+                s_Styles = new Styles();
+
+            GUI.Label(new Rect(0, 0, position.width, position.height), GUIContent.none, s_Styles.background);
+
+            if (s_DirtyList)
+                CreateComponentTree();
+
+            // Keyboard
+            HandleKeyboard();
+
+            GUILayout.Space(7);
+
+            // Search
+            if (!m_ActiveParent.WantsFocus)
+            {
+                EditorGUI.FocusTextInControl("ComponentSearch");
+                Focus();
+            }
+
+            var searchRect = GUILayoutUtility.GetRect(10, 20);
+            searchRect.x += 8;
+            searchRect.width -= 16;
+
+            GUI.SetNextControlName("ComponentSearch");
+
+            using (new EditorGUI.DisabledScope(m_ActiveParent.ShouldDisable))
+            {
+                string newSearch = (string)Invoke(typeof(EditorGUI), null, "SearchField", searchRect, m_DelayedSearch ?? m_Search);
+
+                if (newSearch != m_Search || m_DelayedSearch != null)
+                {
+                    if (!m_IsAnimating)
+                    {
+                        m_Search = m_DelayedSearch ?? newSearch;
+                        EditorPrefs.SetString(k_ComponentSearch, m_Search);
+                        RebuildSearch();
+                        m_DelayedSearch = null;
+                    }
+                    else
+                    {
+                        m_DelayedSearch = newSearch;
+                    }
+                }
+            }
+
+            // Show lists
+            ListGUI(m_ActiveTree, m_Anim, GetElementRelative(0), GetElementRelative(-1));
+            if (m_Anim < 1)
+                ListGUI(m_ActiveTree, m_Anim + 1, GetElementRelative(-1), GetElementRelative(-2));
+
+            // Animate
+            if (m_IsAnimating && Event.current.type == EventType.Repaint)
+            {
+                long now = DateTime.Now.Ticks;
+                float deltaTime = (now - m_LastTime) / (float)TimeSpan.TicksPerSecond;
+                m_LastTime = now;
+                m_Anim = Mathf.MoveTowards(m_Anim, m_AnimTarget, deltaTime * 4);
+
+                if (m_AnimTarget == 0 && Mathf.Approximately(m_Anim, 0))
+                {
+                    m_Anim = 1;
+                    m_AnimTarget = 1;
+                    m_Stack.RemoveAt(m_Stack.Count - 1);
+                }
+
+                Repaint();
+            }
+        }
+
+        void HandleKeyboard()
+        {
+            var evt = Event.current;
+
+            if (evt.type == EventType.KeyDown)
+            {
+                // Special handling when in new script panel
+                if (!m_ActiveParent.HandleKeyboard(evt, s_FilterWindow, GoToParent))
+                {
+                    // Always do these
+                    if (evt.keyCode == KeyCode.DownArrow)
+                    {
+                        m_ActiveParent.selectedIndex++;
+                        m_ActiveParent.selectedIndex = Mathf.Min(m_ActiveParent.selectedIndex, GetChildren(m_ActiveTree, m_ActiveParent).Count - 1);
+                        m_ScrollToSelected = true;
+                        evt.Use();
+                    }
+
+                    if (evt.keyCode == KeyCode.UpArrow)
+                    {
+                        m_ActiveParent.selectedIndex--;
+                        m_ActiveParent.selectedIndex = Mathf.Max(m_ActiveParent.selectedIndex, 0);
+                        m_ScrollToSelected = true;
+                        evt.Use();
+                    }
+
+                    if (evt.keyCode == KeyCode.Return || evt.keyCode == KeyCode.KeypadEnter)
+                    {
+                        GoToChild(m_ActiveElement, true);
+                        evt.Use();
+                    }
+
+                    // Do these if we're not in search mode
+                    if (!m_HasSearch)
+                    {
+                        if (evt.keyCode == KeyCode.LeftArrow || evt.keyCode == KeyCode.Backspace)
+                        {
+                            GoToParent();
+                            evt.Use();
+                        }
+
+                        if (evt.keyCode == KeyCode.RightArrow)
+                        {
+                            GoToChild(m_ActiveElement, false);
+                            evt.Use();
+                        }
+
+                        if (evt.keyCode == KeyCode.Escape)
+                        {
+                            Close();
+                            evt.Use();
+                        }
+                    }
+                }
+            }
+        }
+
+        const string k_SearchHeader = "Search";
+
+        void RebuildSearch()
+        {
+            if (!m_HasSearch)
+            {
+                m_SearchResultTree = null;
+
+                if (m_Stack[m_Stack.Count - 1].name == k_SearchHeader)
+                {
+                    m_Stack.Clear();
+                    m_Stack.Add(m_Tree[0] as GroupElement);
+                }
+
+                m_AnimTarget = 1;
+                m_LastTime = DateTime.Now.Ticks;
+                return;
+            }
+
+            // Support multiple search words separated by spaces.
+            var searchWords = m_Search.ToLower().Split(' ');
+
+            // We keep two lists. Matches that matches the start of an item always get first priority.
+            var matchesStart = new List<Element>();
+            var matchesWithin = new List<Element>();
+
+            foreach (var e in m_Tree)
+            {
+                if (e is GroupElement)
+                    continue;
+
+                string name = e.name.ToLower().Replace(" ", "");
+                bool didMatchAll = true;
+                bool didMatchStart = false;
+
+                // See if we match ALL the seaarch words.
+                for (int w = 0; w < searchWords.Length; w++)
+                {
+                    string search = searchWords[w];
+
+                    if (name.Contains(search))
+                    {
+                        // If the start of the item matches the first search word, make a note of that.
+                        if (w == 0 && name.StartsWith(search))
+                            didMatchStart = true;
+                    }
+                    else
+                    {
+                        // As soon as any word is not matched, we disregard this item.
+                        didMatchAll = false;
+                        break;
+                    }
+                }
+
+                // We always need to match all search words.
+                // If we ALSO matched the start, this item gets priority.
+                if (didMatchAll)
+                {
+                    if (didMatchStart)
+                        matchesStart.Add(e);
+                    else
+                        matchesWithin.Add(e);
+                }
+            }
+
+            matchesStart.Sort();
+            matchesWithin.Sort();
+
+            // Create search tree
+            var tree = new List<Element>();
+
+            // Add parent
+            tree.Add(new GroupElement(0, k_SearchHeader));
+
+            // Add search results
+            tree.AddRange(matchesStart);
+            tree.AddRange(matchesWithin);
+
+            // Create search result tree
+            m_SearchResultTree = tree.ToArray();
+            m_Stack.Clear();
+            m_Stack.Add(m_SearchResultTree[0] as GroupElement);
+
+            // Always select the first search result when search is changed (e.g. a character was typed in or deleted),
+            // because it's usually the best match.
+            if (GetChildren(m_ActiveTree, m_ActiveParent).Count >= 1)
+                m_ActiveParent.selectedIndex = 0;
+            else
+                m_ActiveParent.selectedIndex = -1;
+        }
+
+        GroupElement GetElementRelative(int rel)
+        {
+            int i = m_Stack.Count + rel - 1;
+
+            if (i < 0)
+                return null;
+
+            return m_Stack[i];
+        }
+
+        void GoToParent()
+        {
+            if (m_Stack.Count > 1)
+            {
+                m_AnimTarget = 0;
+                m_LastTime = DateTime.Now.Ticks;
+            }
+        }
+
+        void ListGUI(Element[] tree, float anim, GroupElement parent, GroupElement grandParent)
+        {
+            // Smooth the fractional part of the anim value
+            anim = Mathf.Floor(anim) + Mathf.SmoothStep(0, 1, Mathf.Repeat(anim, 1));
+
+            // Calculate rect for animated area
+            var animRect = position;
+            animRect.x = position.width * (1 - anim) + 1;
+            animRect.y = k_HeaderHeight;
+            animRect.height -= k_HeaderHeight + k_HelpHeight;
+            animRect.width -= 2;
+
+            // Start of animated area (the part that moves left and right)
+            GUILayout.BeginArea(animRect);
+
+            // Header
+            var headerRect = GUILayoutUtility.GetRect(10, 25);
+            string name = parent.name;
+            GUI.Label(headerRect, name, s_Styles.header);
+
+            // Back button
+            if (grandParent != null)
+            {
+                var arrowRect = new Rect(headerRect.x + 4, headerRect.y + 7, 13, 13);
+                var e = Event.current;
+
+                if (e.type == EventType.Repaint)
+                    s_Styles.leftArrow.Draw(arrowRect, false, false, false, false);
+
+                if (e.type == EventType.MouseDown && headerRect.Contains(e.mousePosition))
+                {
+                    GoToParent();
+                    e.Use();
+                }
+            }
+
+            if (!parent.OnGUI(s_FilterWindow))
+                ListGUI(tree, parent);
+
+            GUILayout.EndArea();
+        }
+
+        void GoToChild(Element e, bool addIfComponent)
+        {
+            if (m_Provider.GoToChild(e, addIfComponent))
+            {
+                Close();
+            }
+            else if (!m_HasSearch)
+            {
+                m_LastTime = DateTime.Now.Ticks;
+
+                if (m_AnimTarget == 0)
+                {
+                    m_AnimTarget = 1;
+                }
+                else if (Mathf.Approximately(m_Anim, 1f))
+                {
+                    m_Anim = 0;
+                    m_Stack.Add(e as GroupElement);
+                }
+            }
+        }
+
+        void ListGUI(Element[] tree, GroupElement parent)
+        {
+            // Start of scroll view list
+            parent.scroll = GUILayout.BeginScrollView(parent.scroll);
+
+            EditorGUIUtility.SetIconSize(new Vector2(16, 16));
+
+            var children = GetChildren(tree, parent);
+            var selectedRect = new Rect();
+            var evt = Event.current;
+
+            // Iterate through the children
+            for (int i = 0; i < children.Count; i++)
+            {
+                var e = children[i];
+                var r = GUILayoutUtility.GetRect(16, 20, GUILayout.ExpandWidth(true));
+
+                // Select the element the mouse cursor is over.
+                // Only do it on mouse move - keyboard controls are allowed to overwrite this until the next time the mouse moves.
+                if (evt.type == EventType.MouseMove || evt.type == EventType.MouseDown)
+                {
+                    if (parent.selectedIndex != i && r.Contains(evt.mousePosition))
+                    {
+                        parent.selectedIndex = i;
+                        Repaint();
+                    }
+                }
+
+                bool selected = false;
+
+                // Handle selected item
+                if (i == parent.selectedIndex)
+                {
+                    selected = true;
+                    selectedRect = r;
+                }
+
+                // Draw element
+                if (evt.type == EventType.Repaint)
+                {
+                    var labelStyle = (e is GroupElement) ? s_Styles.groupButton : s_Styles.componentButton;
+                    labelStyle.Draw(r, e.content, false, false, selected, selected);
+
+                    if (e is GroupElement)
+                    {
+                        var arrowRect = new Rect(r.x + r.width - 13, r.y + 4, 13, 13);
+                        s_Styles.rightArrow.Draw(arrowRect, false, false, false, false);
+                    }
+                }
+
+                if (evt.type == EventType.MouseDown && r.Contains(evt.mousePosition))
+                {
+                    evt.Use();
+                    parent.selectedIndex = i;
+                    GoToChild(e, true);
+                }
+            }
+
+            EditorGUIUtility.SetIconSize(Vector2.zero);
+
+            GUILayout.EndScrollView();
+
+            // Scroll to show selected
+            if (m_ScrollToSelected && evt.type == EventType.Repaint)
+            {
+                m_ScrollToSelected = false;
+                var scrollRect = GUILayoutUtility.GetLastRect();
+
+                if (selectedRect.yMax - scrollRect.height > parent.scroll.y)
+                {
+                    parent.scroll.y = selectedRect.yMax - scrollRect.height;
+                    Repaint();
+                }
+
+                if (selectedRect.y < parent.scroll.y)
+                {
+                    parent.scroll.y = selectedRect.y;
+                    Repaint();
+                }
+            }
+        }
+
+        List<Element> GetChildren(Element[] tree, Element parent)
+        {
+            var children = new List<Element>();
+            int level = -1;
+            int i;
+
+            for (i = 0; i < tree.Length; i++)
+            {
+                if (tree[i] == parent)
+                {
+                    level = parent.level + 1;
+                    i++;
+                    break;
+                }
+            }
+
+            if (level == -1)
+                return children;
+
+            for (; i < tree.Length; i++)
+            {
+                var e = tree[i];
+
+                if (e.level < level)
+                    break;
+
+                if (e.level > level && !m_HasSearch)
+                    continue;
+
+                children.Add(e);
+            }
+
+            return children;
+        }
+    }
+}

ScriptableRenderPipeline/Core/Editor/FilterWindow.cs.meta

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

ScriptableRenderPipeline/Core/Editor/Volume/VolumeComponentProvider.cs

+using System;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Experimental.Rendering;
+
+namespace UnityEditor.Experimental.Rendering
+{
+    using IProvider = FilterWindow.IProvider;
+    using Element = FilterWindow.Element;
+    using GroupElement = FilterWindow.GroupElement;
+
+    class VolumeComponentProvider : IProvider
+    {
+        class VolumeComponentElement : Element
+        {
+            public Type type;
+
+            public VolumeComponentElement(int level, string label, Type type)
+            {
+                this.level = level;
+                this.type = type;
+                // TODO: Add support for custom icons
+                content = new GUIContent(label);
+            }
+        }
+
+        class PathNode : IComparable<PathNode>
+        {
+            public List<PathNode> nodes =  new List<PathNode>();
+            public string name;
+            public Type type;
+
+            public int CompareTo(PathNode other)
+            {
+                return name.CompareTo(other.name);
+            }
+        }
+
+        public Vector2 position { get; set; }
+
+        Volume m_Target;
+        VolumeEditor m_TargetEditor;
+
+        public VolumeComponentProvider(Volume target, VolumeEditor targetEditor)
+        {
+            m_Target = target;
+            m_TargetEditor = targetEditor;
+        }
+
+        public void CreateComponentTree(List<Element> tree)
+        {
+            tree.Add(new GroupElement(0, "Volume Components"));
+
+            var attrType = typeof(VolumeComponentMenu);
+            var types = VolumeManager.instance.baseComponentTypes;
+            var rootNode = new PathNode();
+
+            foreach (var t in types)
+            {
+                // Skip components that have already been added to the volume
+                if (m_Target.Has(t))
+                    continue;
+
+                string path = string.Empty;
+
+                // Look for a VolumeComponentMenu attribute
+                var attrs = t.GetCustomAttributes(attrType, false);
+                if (attrs.Length > 0)
+                {
+                    var attr = attrs[0] as VolumeComponentMenu;
+                    if (attr != null)
+                        path = attr.menu;
+                }
+
+                // If no attribute or in case something went wrong when grabbing it, fallback to a
+                // beautified class name
+                if (string.IsNullOrEmpty(path))
+                    path = ObjectNames.NicifyVariableName(t.Name);
+
+                // Prep the categories & types tree
+                AddNode(rootNode, path, t);
+            }
+
+            // Recursively add all elements to the tree
+            Traverse(rootNode, 1, tree);
+        }
+
+        public bool GoToChild(Element element, bool addIfComponent)
+        {
+            if (element is VolumeComponentElement)
+            {
+                var e = (VolumeComponentElement)element;
+                m_TargetEditor.AddComponent(e.type);
+                return true;
+            }
+
+            return false;
+        }
+
+        void AddNode(PathNode root, string path, Type type)
+        {
+            var current = root;
+            var parts = path.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
+
+            foreach (var part in parts)
+            {
+                var child = current.nodes.Find(x => x.name == part);
+
+                if (child == null)
+                {
+                    child = new PathNode { name = part, type = type };
+                    current.nodes.Add(child);
+                }
+
+                current = child;
+            }
+        }
+
+        void Traverse(PathNode node, int depth, List<Element> tree)
+        {
+            node.nodes.Sort();
+
+            foreach (var n in node.nodes)
+            {
+                if (n.nodes.Count > 0) // Group
+                {
+                    tree.Add(new GroupElement(depth, n.name));
+                    Traverse(n, depth + 1, tree);
+                }
+                else // Element
+                {
+                    tree.Add(new VolumeComponentElement(depth, n.name, n.type));
+                }
+            }
+        }
+    }
+}

ScriptableRenderPipeline/Core/Editor/Volume/VolumeComponentProvider.cs.meta

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

ScriptableRenderPipeline/Core/ShaderLibrary/Sampling.meta

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

ScriptableRenderPipeline/Core/Volume/VolumeStack.cs

+using System;
+using System.Collections.Generic;
+
+namespace UnityEngine.Experimental.Rendering
+{
+    public sealed class VolumeStack : IDisposable
+    {
+        // Holds the state of _all_ component types you can possibly add on volumes
+        public readonly Dictionary<Type, VolumeComponent> components;
+
+        internal VolumeStack(IEnumerable<Type> baseTypes)
+        {
+            components = new Dictionary<Type, VolumeComponent>();
+
+            foreach (var type in baseTypes)
+            {
+                var inst = (VolumeComponent)ScriptableObject.CreateInstance(type);
+                components.Add(type, inst);
+            }
+        }
+
+        public T GetComponent<T>()
+            where T : VolumeComponent
+        {
+            var comp = GetComponent(typeof(T));
+            return (T)comp;
+        }
+
+        public VolumeComponent GetComponent(Type type)
+        {
+            VolumeComponent comp;
+            components.TryGetValue(type, out comp);
+            return comp;
+        }
+
+        public void Dispose()
+        {
+            foreach (var component in components)
+                CoreUtils.Destroy(component.Value);
+
+            components.Clear();
+        }
+    }
+}

ScriptableRenderPipeline/Core/Volume/VolumeStack.cs.meta

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

ScriptableRenderPipeline/HDRenderPipeline/RenderPipelineResources/CopyStencilBuffer.shader.meta

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

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/CommonAssets/Materials/Transparent.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: Transparent
+  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
+  m_ShaderKeywords: _ALBEDOAFFECTEMISSIVE_OFF _ALPHACUTOFFENABLE_OFF _BLENDMODE_ALPHA
+    _BLENDMODE_PRESERVE_SPECULAR_LIGHTING _DEPTHOFFSETENABLE_OFF _DISTORTIONENABLE_OFF
+    _DOUBLESIDEDENABLE_OFF _ENABLESPECULAROCCLUSION_OFF _ENABLEWIND_OFF _ENABLE_FOG_ON_TRANSPARENT
+    _NORMALMAP_TANGENT_SPACE _PREREFRACTIONPASS_OFF _SURFACE_TYPE_TRANSPARENT _TRANSPARENTBACKFACEENABLE_OFF
+    _TRANSPARENTDEPTHPOSTPASSENABLE_OFF
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: 3000
+  stringTagMap:
+    RenderType: Transparent
+  disabledShaderPasses:
+  - DistortionVectors
+  - TransparentDepthPostpass
+  - TransparentBackface
+  - TransparentBackfaceDebugDisplay
+  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}
+    - _BentNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BentNormalMapOS:
+        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}
+    - _DistortionVectorMap:
+        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}
+    - _NormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularColorMap:
+        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}
+    - _TangentMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ThicknessMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TransmittanceColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _AORemapMax: 1
+    - _AORemapMin: 0
+    - _ATDistance: 1
+    - _AlbedoAffectEmissive: 0
+    - _AlphaCutoff: 0.5
+    - _AlphaCutoffEnable: 0
+    - _AlphaCutoffPostpass: 0.5
+    - _Anisotropy: 0
+    - _BlendMode: 0
+    - _CoatCoverage: 1
+    - _CoatIOR: 0.5
+    - _CullMode: 2
+    - _CullModeForward: 2
+    - _Cutoff: 0.5
+    - _DepthOffsetEnable: 0
+    - _DetailAlbedoScale: 1
+    - _DetailNormalScale: 1
+    - _DetailSmoothnessScale: 1
+    - _DisplacementLockObjectScale: 1
+    - _DisplacementLockTilingScale: 1
+    - _DisplacementMode: 0
+    - _DistortionBlendMode: 0
+    - _DistortionBlurBlendMode: 0
+    - _DistortionBlurDstBlend: 1
+    - _DistortionBlurRemapMax: 1
+    - _DistortionBlurRemapMin: 0
+    - _DistortionBlurScale: 1
+    - _DistortionBlurSrcBlend: 1
+    - _DistortionDepthTest: 1
+    - _DistortionDstBlend: 1
+    - _DistortionEnable: 0
+    - _DistortionScale: 1
+    - _DistortionSrcBlend: 1
+    - _DistortionVectorBias: -1
+    - _DistortionVectorScale: 2
+    - _DoubleSidedEnable: 0
+    - _DoubleSidedNormalMode: 1
+    - _Drag: 1
+    - _DstBlend: 10
+    - _EmissiveColorMode: 1
+    - _EmissiveIntensity: 0
+    - _EnableBlendModePreserveSpecularLighting: 1
+    - _EnableFogOnTransparent: 1
+    - _EnableSpecularOcclusion: 0
+    - _EnableWind: 0
+    - _HeightAmplitude: 0.02
+    - _HeightCenter: 0.5
+    - _HeightMax: 1
+    - _HeightMin: -1
+    - _IOR: 1
+    - _InitialBend: 1
+    - _InvTilingScale: 1
+    - _LinkDetailsWithBase: 1
+    - _MaterialID: 1
+    - _Metallic: 0
+    - _NormalMapSpace: 0
+    - _NormalScale: 1
+    - _PPDLodThreshold: 5
+    - _PPDMaxSamples: 15
+    - _PPDMinSamples: 5
+    - _PPDPrimitiveLength: 1
+    - _PPDPrimitiveWidth: 1
+    - _PreRefractionPass: 0
+    - _RefractionMode: 0
+    - _ShiverDirectionality: 0.5
+    - _ShiverDrag: 0.2
+    - _Smoothness: 0.5
+    - _SmoothnessRemapMax: 1
+    - _SmoothnessRemapMin: 0
+    - _SrcBlend: 1
+    - _StencilRef: 2
+    - _Stiffness: 1
+    - _SubsurfaceProfile: 0
+    - _SubsurfaceRadius: 1
+    - _SurfaceType: 1
+    - _TexWorldScale: 1
+    - _Thickness: 1
+    - _ThicknessMultiplier: 1
+    - _TransparentBackfaceEnable: 0
+    - _TransparentDepthPostpassEnable: 0
+    - _UVBase: 0
+    - _UVDetail: 0
+    - _ZTestMode: 4
+    - _ZWrite: 0
+    m_Colors:
+    - _BaseColor: {r: 0.51, g: 0.74935526, b: 1, a: 0.5019608}
+    - _Color: {r: 0.50999993, g: 0.74935526, b: 1, a: 0.5019608}
+    - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0}
+    - _EmissionColor: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissiveColor: {r: 1, g: 1, b: 1, a: 1}
+    - _InvPrimScale: {r: 1, g: 1, b: 0, a: 0}
+    - _SpecularColor: {r: 1, g: 1, b: 1, a: 1}
+    - _ThicknessRemap: {r: 0, g: 1, b: 0, a: 0}
+    - _TransmittanceColor: {r: 1, g: 1, b: 1, a: 1}
+    - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/CommonAssets/Materials/Transparent.mat.meta

+fileFormatVersion: 2
+guid: 2505e1d9c7a8c654487d6a2dcae04242
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/2xxx_Lighting/2201_Env_SurfaceReactions.meta

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

ScriptableRenderPipeline/Core/ShaderLibrary/Filtering.hlsl

-// Ref: https://gist.github.com/TheRealMJP/c83b8c0f46b63f3a88a5986f4fa982b1 from MJP
-// Samples a texture with Catmull-Rom filtering, using 9 texture fetches instead of 16.
-// See http://vec3.ca/bicubic-filtering-in-fewer-taps/ for more details
-float4 SampleTextureCatmullRom(TEXTURE2D_ARGS(tex, linearSampler), float2 uv, float2 texSize)
-{
-    // We're going to sample a a 4x4 grid of texels surrounding the target UV coordinate. We'll do this by rounding
-    // down the sample location to get the exact center of our "starting" texel. The starting texel will be at
-    // location [1, 1] in the grid, where [0, 0] is the top left corner.
-    float2 samplePos = uv * texSize;
-    float2 texPos1 = floor(samplePos - 0.5f) + 0.5f;
-
-    // Compute the fractional offset from our starting texel to our original sample location, which we'll
-    // feed into the Catmull-Rom spline function to get our filter weights.
-    float2 f = samplePos - texPos1;
-    float2 f2 = f * f;
-    float2 f3 = f2 * f;
-
-    // Compute the Catmull-Rom weights using the fractional offset that we calculated earlier.
-    // These equations are pre-expanded based on our knowledge of where the texels will be located,
-    // which lets us avoid having to evaluate a piece-wise function.
-    float2 w0 = (1.0f / 6.0) * (-3.0 * f3 + 6.0 * f2 - 3.0 * f);
-    float2 w1 = (1.0f / 6.0) * (9.0 * f3 - 15.0 * f2 + 6.0);
-    float2 w2 = (1.0f / 6.0) * (-9.0 * f3 + 12.0 * f2 + 3.0 * f);
-    float2 w3 = (1.0f / 6.0) * (3.0 * f3 - 3.0 * f2);
-
-    // Otim by Vlad, to test
-    // float2 w0 = (1.0 / 2.0) * f * (-1.0 + f * (2.0 - f));
-    // float2 w1 = (1.0 / 6.0) * f2 * (-15.0 + 9.0 * f)) + 1.0;
-    // float2 w2 = (1.0 / 6.0) * f * (3.0 + f * (12.0 - f * 9.0));
-    // float2 w3 = (1.0 / 2.0) * f2 * (f - 1.0);
-
-    // Work out weighting factors and sampling offsets that will let us use bilinear filtering to
-    // simultaneously evaluate the middle 2 samples from the 4x4 grid.
-    float2 w12 = w1 + w2;
-    float2 offset12 = w2 / (w1 + w2);
-
-    // Compute the final UV coordinates we'll use for sampling the texture
-    float2 texPos0 = texPos1 - 1;
-    float2 texPos3 = texPos1 + 2;
-    float2 texPos12 = texPos1 + offset12;
-
-    texPos0 /= texSize;
-    texPos3 /= texSize;
-    texPos12 /= texSize;
-
-    float4 result = 0.0;
-    result += TEXTURE2D_SAMPLE_LOD(tex, linearSampler, float2(texPos0.x, texPos0.y), 0.0) * w0.x * w0.y;
-    result += TEXTURE2D_SAMPLE_LOD(tex, linearSampler, float2(texPos12.x, texPos0.y), 0.0) * w12.x * w0.y;
-    result += TEXTURE2D_SAMPLE_LOD(tex, linearSampler, float2(texPos3.x, texPos0.y), 0.0) * w3.x * w0.y;
-
-    result += TEXTURE2D_SAMPLE_LOD(tex, linearSampler, float2(texPos0.x, texPos12.y), 0.0) * w0.x * w12.y;
-    result += TEXTURE2D_SAMPLE_LOD(tex, linearSampler, float2(texPos12.x, texPos12.y), 0.0) * w12.x * w12.y;
-    result += TEXTURE2D_SAMPLE_LOD(tex, linearSampler, float2(texPos3.x, texPos12.y), 0.0) * w3.x * w12.y;
-
-    result += TEXTURE2D_SAMPLE_LOD(tex, linearSampler, float2(texPos0.x, texPos3.y), 0.0) * w0.x * w3.y;
-    result += TEXTURE2D_SAMPLE_LOD(tex, linearSampler, float2(texPos12.x, texPos3.y), 0.0) * w12.x * w3.y;
-    result += TEXTURE2D_SAMPLE_LOD(tex, linearSampler, float2(texPos3.x, texPos3.y), 0.0) * w3.x * w3.y;
-
-    return result;
-}
-
-/*
-
-// manual tri-linearly interpolated texture fetch
-// not really needed: used hard-wired texture interpolation
-vec4 manualTexture3D( sampler3D samp, vec3 p ){
-vec3 qa = p*uvMapSize + vec3(0.5);
-vec3 qi = floor(qa);
-qa -= qi;
-qi -= vec3(0.5);
-return
-mix( mix( mix( texture3D( samp, (qi+vec3(0.0,0.0,0.0))*oneOverUvMapSize ),
-texture3D( samp, (qi+vec3(1.0,0.0,0.0))*oneOverUvMapSize ), qa.x ),
-mix( texture3D( samp, (qi+vec3(0.0,1.0,0.0))*oneOverUvMapSize ),
-texture3D( samp, (qi+vec3(1.0,1.0,0.0))*oneOverUvMapSize ), qa.x ), qa.y ),
-mix( mix( texture3D( samp, (qi+vec3(0.0,0.0,1.0))*oneOverUvMapSize ),
-texture3D( samp, (qi+vec3(1.0,0.0,1.0))*oneOverUvMapSize ), qa.x ),
-mix( texture3D( samp, (qi+vec3(0.0,1.0,1.0))*oneOverUvMapSize ),
-texture3D( samp, (qi+vec3(1.0,1.0,1.0))*oneOverUvMapSize ), qa.x ), qa.y ), qa.z );
-
-}
-*/

ScriptableRenderPipeline/Core/ShaderLibrary/Filtering.hlsl.meta

-fileFormatVersion: 2
-guid: dac42c6a533d53b41b931e02431564fa
-timeCreated: 1474355143
-licenseType: Pro
-DefaultImporter:
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

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

-fileFormatVersion: 2
-guid: 7fd941b2d9d2a39429de64bde023932c
-timeCreated: 1499946987
-licenseType: Pro
-ShaderImporter:
-  externalObjects: {}
-  defaultTextures: []
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: