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

# Conflicts:
#	ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipeline.cs
#	ScriptableRenderPipeline/HDRenderPipeline/Material/GGXConvolution/RuntimeFilterIBL.cs
#	ScriptableRenderPipeline/HDRenderPipeline/Sky/SkyManager.cs

LICENSE

-MIT License
+Unity Companion License (“License”)
+Software Copyright © 2017 Unity Technologies ApS 
-Copyright (c) 2016 Unity Technologies
+Unity Technologies ApS (“Unity”) grants to you a worldwide, non-exclusive,
+no-charge, and royalty-free copyright license to reproduce, prepare derivative
+works of, publicly display, publicly perform, sublicense, and distribute the
+software that is made available under this License (“Software”), subject to the
+following terms and conditions: 
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
+1. Unity Companion Use Only. Exercise of the license granted herein is limited
+to exercise for the creation, use, and/or distribution of applications,
+software, or other content pursuant to a valid Unity content authoring and
+rendering engine software license (“Engine License”). That means while use of
+the Software is not limited to use in the software licensed under the Engine
+License, the Software may not be used for any purpose other than the creation,
+use, and/or distribution of Engine License-dependent applications, software, or
+other content. No other exercise of the license granted herein is permitted,
+and in no event may the Software be used for competitive analysis or to develop
+a competing product or service.
+
+2. No Modification of Engine License. Neither this License nor any exercise of
+the license granted herein modifies the Engine License in any way.
+
+3. Ownership & Grant Back to You. 
+
+3.1 You own your content. In this License, “derivative works” means derivatives
+of the Software itself--works derived only from the Software by you under this
+License (for example, modifying the code of the Software itself to improve its
+efficacy); “derivative works” of the Software do not include, for example,
+games, apps, or content that you create using the Software. You keep all right,
+title, and interest to your own content.
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
+3.2 Unity owns its content. While you keep all right, title, and interest to
+your own content per the above, as between Unity and you, Unity will own all
+right, title, and interest to all intellectual property rights (including
+patent, trademark, and copyright) in the Software and derivative works of the
+Software, and you hereby assign and agree to assign all such rights in those
+derivative works to Unity. 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+3.3 You have a license to those derivative works. Subject to this License,
+Unity grants to you the same worldwide, non-exclusive, no-charge, and
+royalty-free copyright license to derivative works of the Software you create
+as is granted to you for the Software under this License.
+
+4. Trademarks. You are not granted any right or license under this License to
+use any trademarks, service marks, trade names, products names, or branding of
+Unity or its affiliates (“Trademarks”). Descriptive uses of Trademarks are
+permitted; see, for example, Unity’s Branding Usage Guidelines at
+https://unity3d.com/public-relations/brand.
+
+5. Notices & Third-Party Rights. This License, including the copyright notice
+associated with the Software, must be provided in all substantial portions of
+the Software and derivative works thereof (or, if that is impracticable, in any
+other location where such notices are customarily placed). Further, if the
+Software is accompanied by a Unity “third-party notices” or similar file, you
+acknowledge and agree that software identified in that file is governed by
+those separate license terms.
+
+6. DISCLAIMER, LIMITATION OF LIABILITY. THE SOFTWARE AND ANY DERIVATIVE WORKS
+THEREOF IS PROVIDED ON AN "AS IS" BASIS, AND IS PROVIDED WITHOUT WARRANTY OF
+ANY KIND, WHETHER EXPRESS OR IMPLIED, INCLUDING ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND/OR NONINFRINGEMENT. IN
+NO EVENT SHALL ANY COPYRIGHT HOLDER OR AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES
+(WHETHER DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL,
+INCLUDING PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, LOSS OF USE, DATA, OR
+PROFITS, AND BUSINESS INTERRUPTION), OR OTHER LIABILITY WHATSOEVER, WHETHER IN
+AN ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING FROM OR OUT OF, OR IN
+CONNECTION WITH, THE SOFTWARE OR ANY DERIVATIVE WORKS THEREOF OR THE USE OF OR
+OTHER DEALINGS IN SAME, EVEN WHERE ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+7. USE IS ACCEPTANCE and License Versions. Your receipt and use of the Software
+constitutes your acceptance of this License and its terms and conditions.
+Software released by Unity under this License may be modified or updated and
+the License with it; upon any such modification or update, you will comply with
+the terms of the updated License for any use of any of the Software under the
+updated License. 
+
+8. Use in Compliance with Law and Termination. Your exercise of the license
+granted herein will at all times be in compliance with applicable law and will
+not infringe any proprietary rights (including intellectual property rights);
+this License will terminate immediately on any breach by you of this License.
+
+9. Severability. If any provision of this License is held to be unenforceable
+or invalid, that provision will be enforced to the maximum extent possible and
+the other provisions will remain in full force and effect.
+
+10. Governing Law and Venue. This License is governed by and construed in
+accordance with the laws of Denmark, except for its conflict of laws rules; the
+United Nations Convention on Contracts for the International Sale of Goods will
+not apply. If you reside (or your principal place of business is) within the
+United States, you and Unity agree to submit to the personal and exclusive
+jurisdiction of and venue in the state and federal courts located in San
+Francisco County, California concerning any dispute arising out of this License
+(“Dispute”). If you reside (or your principal place of business is) outside the
+United States, you and Unity agree to submit to the personal and exclusive
+jurisdiction of and venue in the courts located in Copenhagen, Denmark
+concerning any Dispute. 

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/BlitCubeTextureFace.shader

             #pragma target 3.0
 
             TEXTURECUBE(_InputTex);
-            SAMPLERCUBE(sampler_InputTex);
+            SAMPLER(sampler_InputTex);
 
             float _FaceIndex;
             float _LoD;

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

 
 // Texture abstraction
 
-#define TEXTURE2D(textureName) Texture2D textureName
-#define TEXTURE2D_ARRAY(textureName) Texture2DArray textureName
-#define TEXTURECUBE(textureName) TextureCube textureName
-#define TEXTURECUBE_ARRAY(textureName) TextureCubeArray textureName
-#define TEXTURE3D(textureName) Texture3D textureName
-#define RW_TEXTURE2D(type, textureName) RWTexture2D<type> textureName
+#define TEXTURE2D(textureName)                Texture2D textureName
+#define TEXTURE2D_ARRAY(textureName)          Texture2DArray textureName
+#define TEXTURECUBE(textureName)              TextureCube textureName
+#define TEXTURECUBE_ARRAY(textureName)        TextureCubeArray textureName
+#define TEXTURE3D(textureName)                Texture3D textureName
+
+#define TEXTURE2D_SHADOW(textureName)         TEXTURE2D(textureName)
+#define TEXTURE2D_ARRAY_SHADOW(textureName)   TEXTURE2D_ARRAY(textureName)
+#define TEXTURECUBE_SHADOW(textureName)       TEXTURECUBE(textureName)
+#define TEXTURECUBE_ARRAY_SHADOW(textureName) TEXTURECUBE_ARRAY(textureName)
-#define SAMPLER2D(samplerName) SamplerState samplerName
-#define SAMPLERCUBE(samplerName) SamplerState samplerName
-#define SAMPLER3D(samplerName) SamplerState samplerName
-#define SAMPLER2D_SHADOW(samplerName) SamplerComparisonState samplerName
-#define SAMPLERCUBE_SHADOW(samplerName) SamplerComparisonState samplerName
+#define RW_TEXTURE2D(type, textureName)       RWTexture2D<type> textureName
+#define RW_TEXTURE3D(type, textureName)       RWTexture3D<type> textureName
+
+#define SAMPLER(samplerName)                  SamplerState samplerName
+#define SAMPLER_CMP(samplerName)              SamplerComparisonState samplerName
+
+#define TEXTURE2D_ARGS(textureName, samplerName)                 TEXTURE2D(textureName),         SAMPLER(samplerName)
+#define TEXTURE2D_ARRAY_ARGS(textureName, samplerName)           TEXTURE2D_ARRAY(textureName),   SAMPLER(samplerName)
+#define TEXTURECUBE_ARGS(textureName, samplerName)               TEXTURECUBE(textureName),       SAMPLER(samplerName)
+#define TEXTURECUBE_ARRAY_ARGS(textureName, samplerName)         TEXTURECUBE_ARRAY(textureName), SAMPLER(samplerName)
+#define TEXTURE3D_ARGS(textureName, samplerName)                 TEXTURE3D(textureName),         SAMPLER(samplerName)
+
+#define TEXTURE2D_SHADOW_ARGS(textureName, samplerName)          TEXTURE2D(textureName),         SAMPLER_CMP(samplerName)
+#define TEXTURE2D_ARRAY_SHADOW_ARGS(textureName, samplerName)    TEXTURE2D_ARRAY(textureName),   SAMPLER_CMP(samplerName)
+#define TEXTURECUBE_SHADOW_ARGS(textureName, samplerName)        TEXTURECUBE(textureName),       SAMPLER_CMP(samplerName)
+#define TEXTURECUBE_ARRAY_SHADOW_ARGS(textureName, samplerName)  TEXTURECUBE_ARRAY(textureName), SAMPLER_CMP(samplerName)
-#define TEXTURE2D_ARGS(textureName, samplerName) Texture2D textureName, SamplerState samplerName
-#define TEXTURE2D_ARRAY_ARGS(textureName, samplerName) Texture2DArray textureName, SamplerState samplerName
-#define TEXTURECUBE_ARGS(textureName, samplerName) TextureCube textureName, SamplerState samplerName
-#define TEXTURECUBE_ARRAY_ARGS(textureName, samplerName) TextureCubeArray textureName, SamplerState samplerName
-#define TEXTURE3D_ARGS(textureName, samplerName) Texture3D textureName, SamplerState samplerName
-#define TEXTURE2D_SHADOW_ARGS(textureName, samplerName) Texture2D textureName, SamplerComparisonState samplerName
-#define TEXTURE2D_ARRAY_SHADOW_ARGS(textureName, samplerName) Texture2DArray textureName, SamplerComparisonState samplerName
-#define TEXTURECUBE_SHADOW_ARGS(textureName, samplerName) TextureCube textureName, SamplerComparisonState samplerName
+#define TEXTURE2D_PARAM(textureName, samplerName)                textureName, samplerName
+#define TEXTURE2D_ARRAY_PARAM(textureName, samplerName)          textureName, samplerName
+#define TEXTURECUBE_PARAM(textureName, samplerName)              textureName, samplerName
+#define TEXTURECUBE_ARRAY_PARAM(textureName, samplerName)        textureName, samplerName
+#define TEXTURE3D_PARAM(textureName, samplerName)                textureName, samplerName
-#define TEXTURE2D_PARAM(textureName, samplerName) textureName, samplerName
-#define TEXTURE2D_ARRAY_PARAM(textureName, samplerName) textureName, samplerName
-#define TEXTURECUBE_PARAM(textureName, samplerName) textureName, samplerName
-#define TEXTURECUBE_ARRAY_PARAM(textureName, samplerName) textureName, samplerName
-#define TEXTURE3D_PARAM(textureName, samplerName) textureName, samplerName
-#define TEXTURE2D_SHADOW_PARAM(textureName, samplerName) textureName, samplerName
-#define TEXTURE2D_ARRAY_SHADOW_PARAM(textureName, samplerName) textureName, samplerName
-#define TEXTURECUBE_SHADOW_PARAM(textureName, samplerName) textureName, samplerName
+#define TEXTURE2D_SHADOW_PARAM(textureName, samplerName)         textureName, samplerName
+#define TEXTURE2D_ARRAY_SHADOW_PARAM(textureName, samplerName)   textureName, samplerName
+#define TEXTURECUBE_SHADOW_PARAM(textureName, samplerName)       textureName, samplerName
+#define TEXTURECUBE_ARRAY_SHADOW_PARAM(textureName, samplerName) textureName, samplerName
-#define SAMPLE_TEXTURE2D(textureName, samplerName, coord2) textureName.Sample(samplerName, coord2)
-#define SAMPLE_TEXTURE2D_LOD(textureName, samplerName, coord2, lod) textureName.SampleLevel(samplerName, coord2, lod)
-#define SAMPLE_TEXTURE2D_BIAS(textureName, samplerName, coord2, bias) textureName.SampleBias(samplerName, coord2, bias)
-#define SAMPLE_TEXTURE2D_GRAD(textureName, samplerName, coord2, ddx, ddy) textureName.SampleGrad(samplerName, coord2, ddx, ddy)
-#define SAMPLE_TEXTURE2D_ARRAY(textureName, samplerName, coord2, index) textureName.Sample(samplerName, float3(coord2, index))
-#define SAMPLE_TEXTURE2D_ARRAY_LOD(textureName, samplerName, coord2, index, lod) textureName.SampleLevel(samplerName, float3(coord2, index), lod)
-#define SAMPLE_TEXTURE2D_ARRAY_BIAS(textureName, samplerName, coord2, index, bias) textureName.SampleBias(samplerName, float3(coord2, index), bias)
-#define SAMPLE_TEXTURECUBE(textureName, samplerName, coord3) textureName.Sample(samplerName, coord3)
-#define SAMPLE_TEXTURECUBE_LOD(textureName, samplerName, coord3, lod) textureName.SampleLevel(samplerName, coord3, lod)
-#define SAMPLE_TEXTURECUBE_BIAS(textureName, samplerName, coord3, bias) textureName.SampleBias(samplerName, coord3, bias)
-#define SAMPLE_TEXTURECUBE_ARRAY(textureName, samplerName, coord3, index) textureName.Sample(samplerName, float4(coord3, index))
-#define SAMPLE_TEXTURECUBE_ARRAY_LOD(textureName, samplerName, coord3, index, lod) textureName.SampleLevel(samplerName, float4(coord3, index), lod)
+#define SAMPLE_TEXTURE2D(textureName, samplerName, coord2)                           textureName.Sample(samplerName, coord2)
+#define SAMPLE_TEXTURE2D_LOD(textureName, samplerName, coord2, lod)                  textureName.SampleLevel(samplerName, coord2, lod)
+#define SAMPLE_TEXTURE2D_BIAS(textureName, samplerName, coord2, bias)                textureName.SampleBias(samplerName, coord2, bias)
+#define SAMPLE_TEXTURE2D_GRAD(textureName, samplerName, coord2, dpdx, dpdy)          textureName.SampleGrad(samplerName, coord2, dpdx, dpdy)
+#define SAMPLE_TEXTURE2D_ARRAY(textureName, samplerName, coord2, index)              textureName.Sample(samplerName, float3(coord2, index))
+#define SAMPLE_TEXTURE2D_ARRAY_LOD(textureName, samplerName, coord2, index, lod)     textureName.SampleLevel(samplerName, float3(coord2, index), lod)
+#define SAMPLE_TEXTURE2D_ARRAY_BIAS(textureName, samplerName, coord2, index, bias)   textureName.SampleBias(samplerName, float3(coord2, index), bias)
+#define SAMPLE_TEXTURECUBE(textureName, samplerName, coord3)                         textureName.Sample(samplerName, coord3)
+#define SAMPLE_TEXTURECUBE_LOD(textureName, samplerName, coord3, lod)                textureName.SampleLevel(samplerName, coord3, lod)
+#define SAMPLE_TEXTURECUBE_BIAS(textureName, samplerName, coord3, bias)              textureName.SampleBias(samplerName, coord3, bias)
+#define SAMPLE_TEXTURECUBE_ARRAY(textureName, samplerName, coord3, index)            textureName.Sample(samplerName, float4(coord3, index))
+#define SAMPLE_TEXTURECUBE_ARRAY_LOD(textureName, samplerName, coord3, index, lod)   textureName.SampleLevel(samplerName, float4(coord3, index), lod)
-#define SAMPLE_TEXTURE3D(textureName, samplerName, coord3) textureName.Sample(samplerName, coord3)
-#define SAMPLE_TEXTURE2D_SHADOW(textureName, samplerName, coord3) textureName.SampleCmpLevelZero(samplerName, (coord3).xy, (coord3).z)
-#define SAMPLE_TEXTURE2D_ARRAY_SHADOW(textureName, samplerName, coord3, index) textureName.SampleCmpLevelZero(samplerName, float3((coord3).xy, index), (coord3).z)
-#define SAMPLE_TEXTURECUBE_SHADOW(textureName, samplerName, coord4) textureName.SampleCmpLevelZero(samplerName, (coord3).xyz, (coord3).w)
-#define SAMPLE_TEXTURECUBE_ARRAY_SHADOW(textureName, samplerName, coord4, index) textureName.SampleCmpLevelZero(samplerName, float4((coord4).xyz, index), (coord4).w)
+#define SAMPLE_TEXTURE3D(textureName, samplerName, coord3)                           textureName.Sample(samplerName, coord3)
+#define SAMPLE_TEXTURE3D_LOD(textureName, samplerName, coord3, lod) 				 textureName.SampleLevel(samplerName, coord3, lod)
-#define SAMPLE_DEPTH_TEXTURE(textureName, samplerName, coord2) SAMPLE_TEXTURE2D(textureName, samplerName, coord2).r
+#define SAMPLE_TEXTURE2D_SHADOW(textureName, samplerName, coord3)                    textureName.SampleCmpLevelZero(samplerName, (coord3).xy, (coord3).z)
+#define SAMPLE_TEXTURE2D_ARRAY_SHADOW(textureName, samplerName, coord3, index)       textureName.SampleCmpLevelZero(samplerName, float3((coord3).xy, index), (coord3).z)
+#define SAMPLE_TEXTURECUBE_SHADOW(textureName, samplerName, coord4)                  textureName.SampleCmpLevelZero(samplerName, (coord3).xyz, (coord3).w)
+#define SAMPLE_TEXTURECUBE_ARRAY_SHADOW(textureName, samplerName, coord4, index)     textureName.SampleCmpLevelZero(samplerName, float4((coord4).xyz, index), (coord4).w)
+
+#define SAMPLE_DEPTH_TEXTURE(textureName, samplerName, coord2)          SAMPLE_TEXTURE2D(textureName, samplerName, coord2).r
-#define TEXTURE2D_HALF TEXTURE2D
-#define TEXTURE2D_FLOAT TEXTURE2D
-#define TEXTURE3D_HALF TEXTURE3D
-#define TEXTURE3D_FLOAT TEXTURE3D
-#define SAMPLER2D_HALF SAMPLER2D
-#define SAMPLER2D_FLOAT SAMPLER2D
-
-#define LOAD_TEXTURE2D(textureName, unCoord2) textureName.Load(int3(unCoord2, 0))
-#define LOAD_TEXTURE2D_LOD(textureName, unCoord2, lod) textureName.Load(int3(unCoord2, lod))
-#define LOAD_TEXTURE2D_MSAA(textureName, unCoord2, sampleIndex) textureName.Load(unCoord2, sampleIndex)
-#define LOAD_TEXTURE2D_ARRAY(textureName, unCoord2, index) textureName.Load(int4(unCoord2, index, 0))
+#define LOAD_TEXTURE2D(textureName, unCoord2)                       textureName.Load(int3(unCoord2, 0))
+#define LOAD_TEXTURE2D_LOD(textureName, unCoord2, lod)              textureName.Load(int3(unCoord2, lod))
+#define LOAD_TEXTURE2D_MSAA(textureName, unCoord2, sampleIndex)     textureName.Load(unCoord2, sampleIndex)
+#define LOAD_TEXTURE2D_ARRAY(textureName, unCoord2, index)          textureName.Load(int4(unCoord2, index, 0))
-#define GATHER_TEXTURE2D(textureName, samplerName, coord2) textureName.Gather(samplerName, coord2)
-#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_TEXTURE2D(textureName, samplerName, coord2)                textureName.Gather(samplerName, coord2)
+#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_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

 
 // Texture abstraction
 
-#define TEXTURE2D(textureName) Texture2D textureName
-#define TEXTURE2D_ARRAY(textureName) Texture2DArray textureName
-#define TEXTURECUBE(textureName) TextureCube textureName
-#define TEXTURECUBE_ARRAY(textureName) TextureCubeArray textureName
-#define TEXTURE3D(textureName) Texture3D textureName
-#define RW_TEXTURE2D(type, textureName) RWTexture2D<type> textureName
+#define TEXTURE2D(textureName)                Texture2D textureName
+#define TEXTURE2D_ARRAY(textureName)          Texture2DArray textureName
+#define TEXTURECUBE(textureName)              TextureCube textureName
+#define TEXTURECUBE_ARRAY(textureName)        TextureCubeArray textureName
+#define TEXTURE3D(textureName)                Texture3D textureName
+
+#define TEXTURE2D_SHADOW(textureName)         TEXTURE2D(textureName)
+#define TEXTURE2D_ARRAY_SHADOW(textureName)   TEXTURE2D_ARRAY(textureName)
+#define TEXTURECUBE_SHADOW(textureName)       TEXTURECUBE(textureName)
+#define TEXTURECUBE_ARRAY_SHADOW(textureName) TEXTURECUBE_ARRAY(textureName)
-#define SAMPLER2D(samplerName) SamplerState samplerName
-#define SAMPLERCUBE(samplerName) SamplerState samplerName
-#define SAMPLER3D(samplerName) SamplerState samplerName
-#define SAMPLER2D_SHADOW(samplerName) SamplerComparisonState samplerName
-#define SAMPLERCUBE_SHADOW(samplerName) SamplerComparisonState samplerName
+#define RW_TEXTURE2D(type, textureName)       RWTexture2D<type> textureName
+#define RW_TEXTURE3D(type, textureName)       RWTexture3D<type> textureName
+
+#define SAMPLER(samplerName)                  SamplerState samplerName
+#define SAMPLER_CMP(samplerName)              SamplerComparisonState samplerName
+
+#define TEXTURE2D_ARGS(textureName, samplerName)                 TEXTURE2D(textureName),         SAMPLER(samplerName)
+#define TEXTURE2D_ARRAY_ARGS(textureName, samplerName)           TEXTURE2D_ARRAY(textureName),   SAMPLER(samplerName)
+#define TEXTURECUBE_ARGS(textureName, samplerName)               TEXTURECUBE(textureName),       SAMPLER(samplerName)
+#define TEXTURECUBE_ARRAY_ARGS(textureName, samplerName)         TEXTURECUBE_ARRAY(textureName), SAMPLER(samplerName)
+#define TEXTURE3D_ARGS(textureName, samplerName)                 TEXTURE3D(textureName),         SAMPLER(samplerName)
+
+#define TEXTURE2D_SHADOW_ARGS(textureName, samplerName)          TEXTURE2D(textureName),         SAMPLER_CMP(samplerName)
+#define TEXTURE2D_ARRAY_SHADOW_ARGS(textureName, samplerName)    TEXTURE2D_ARRAY(textureName),   SAMPLER_CMP(samplerName)
+#define TEXTURECUBE_SHADOW_ARGS(textureName, samplerName)        TEXTURECUBE(textureName),       SAMPLER_CMP(samplerName)
+#define TEXTURECUBE_ARRAY_SHADOW_ARGS(textureName, samplerName)  TEXTURECUBE_ARRAY(textureName), SAMPLER_CMP(samplerName)
-#define TEXTURE2D_ARGS(textureName, samplerName) Texture2D textureName, SamplerState samplerName
-#define TEXTURE2D_ARRAY_ARGS(textureName, samplerName) Texture2DArray textureName, SamplerState samplerName
-#define TEXTURECUBE_ARGS(textureName, samplerName) TextureCube textureName, SamplerState samplerName
-#define TEXTURECUBE_ARRAY_ARGS(textureName, samplerName) TextureCubeArray textureName, SamplerState samplerName
-#define TEXTURE3D_ARGS(textureName, samplerName) Texture3D textureName, SamplerState samplerName
-#define TEXTURE2D_SHADOW_ARGS(textureName, samplerName) Texture2D textureName, SamplerComparisonState samplerName
-#define TEXTURE2D_ARRAY_SHADOW_ARGS(textureName, samplerName) Texture2DArray textureName, SamplerComparisonState samplerName
-#define TEXTURECUBE_SHADOW_ARGS(textureName, samplerName) TextureCube textureName, SamplerComparisonState samplerName
+#define TEXTURE2D_PARAM(textureName, samplerName)                textureName, samplerName
+#define TEXTURE2D_ARRAY_PARAM(textureName, samplerName)          textureName, samplerName
+#define TEXTURECUBE_PARAM(textureName, samplerName)              textureName, samplerName
+#define TEXTURECUBE_ARRAY_PARAM(textureName, samplerName)        textureName, samplerName
+#define TEXTURE3D_PARAM(textureName, samplerName)                textureName, samplerName
-#define TEXTURE2D_PARAM(textureName, samplerName) textureName, samplerName
-#define TEXTURE2D_ARRAY_PARAM(textureName, samplerName) textureName, samplerName
-#define TEXTURECUBE_PARAM(textureName, samplerName) textureName, samplerName
-#define TEXTURECUBE_ARRAY_PARAM(textureName, samplerName) textureName, samplerName
-#define TEXTURE3D_PARAM(textureName, samplerName) textureName, samplerName
-#define TEXTURE2D_SHADOW_PARAM(textureName, samplerName) textureName, samplerName
-#define TEXTURE2D_ARRAY_SHADOW_PARAM(textureName, samplerName) textureName, samplerName
-#define TEXTURECUBE_SHADOW_PARAM(textureName, samplerName) textureName, samplerName
+#define TEXTURE2D_SHADOW_PARAM(textureName, samplerName)         textureName, samplerName
+#define TEXTURE2D_ARRAY_SHADOW_PARAM(textureName, samplerName)   textureName, samplerName
+#define TEXTURECUBE_SHADOW_PARAM(textureName, samplerName)       textureName, samplerName
+#define TEXTURECUBE_ARRAY_SHADOW_PARAM(textureName, samplerName) textureName, samplerName
-#define SAMPLE_TEXTURE2D(textureName, samplerName, coord2) textureName.Sample(samplerName, coord2)
-#define SAMPLE_TEXTURE2D_LOD(textureName, samplerName, coord2, lod) textureName.SampleLevel(samplerName, coord2, lod)
-#define SAMPLE_TEXTURE2D_BIAS(textureName, samplerName, coord2, bias) textureName.SampleBias(samplerName, coord2, bias)
-#define SAMPLE_TEXTURE2D_GRAD(textureName, samplerName, coord2, ddx, ddy) textureName.SampleGrad(samplerName, coord2, ddx, ddy)
-#define SAMPLE_TEXTURE2D_ARRAY(textureName, samplerName, coord2, index) textureName.Sample(samplerName, float3(coord2, index))
-#define SAMPLE_TEXTURE2D_ARRAY_LOD(textureName, samplerName, coord2, index, lod) textureName.SampleLevel(samplerName, float3(coord2, index), lod)
-#define SAMPLE_TEXTURE2D_ARRAY_BIAS(textureName, samplerName, coord2, index, bias) textureName.SampleBias(samplerName, float3(coord2, index), bias)
-#define SAMPLE_TEXTURECUBE(textureName, samplerName, coord3) textureName.Sample(samplerName, coord3)
-#define SAMPLE_TEXTURECUBE_LOD(textureName, samplerName, coord3, lod) textureName.SampleLevel(samplerName, coord3, lod)
-#define SAMPLE_TEXTURECUBE_BIAS(textureName, samplerName, coord3, bias) textureName.SampleBias(samplerName, coord3, bias)
-#define SAMPLE_TEXTURECUBE_ARRAY(textureName, samplerName, coord3, index) textureName.Sample(samplerName, float4(coord3, index))
-#define SAMPLE_TEXTURECUBE_ARRAY_LOD(textureName, samplerName, coord3, index, lod) textureName.SampleLevel(samplerName, float4(coord3, index), lod)
+#define SAMPLE_TEXTURE2D(textureName, samplerName, coord2)                           textureName.Sample(samplerName, coord2)
+#define SAMPLE_TEXTURE2D_LOD(textureName, samplerName, coord2, lod)                  textureName.SampleLevel(samplerName, coord2, lod)
+#define SAMPLE_TEXTURE2D_BIAS(textureName, samplerName, coord2, bias)                textureName.SampleBias(samplerName, coord2, bias)
+#define SAMPLE_TEXTURE2D_GRAD(textureName, samplerName, coord2, dpdx, dpdy)          textureName.SampleGrad(samplerName, coord2, dpdx, dpdy)
+#define SAMPLE_TEXTURE2D_ARRAY(textureName, samplerName, coord2, index)              textureName.Sample(samplerName, float3(coord2, index))
+#define SAMPLE_TEXTURE2D_ARRAY_LOD(textureName, samplerName, coord2, index, lod)     textureName.SampleLevel(samplerName, float3(coord2, index), lod)
+#define SAMPLE_TEXTURE2D_ARRAY_BIAS(textureName, samplerName, coord2, index, bias)   textureName.SampleBias(samplerName, float3(coord2, index), bias)
+#define SAMPLE_TEXTURECUBE(textureName, samplerName, coord3)                         textureName.Sample(samplerName, coord3)
+#define SAMPLE_TEXTURECUBE_LOD(textureName, samplerName, coord3, lod)                textureName.SampleLevel(samplerName, coord3, lod)
+#define SAMPLE_TEXTURECUBE_BIAS(textureName, samplerName, coord3, bias)              textureName.SampleBias(samplerName, coord3, bias)
+#define SAMPLE_TEXTURECUBE_ARRAY(textureName, samplerName, coord3, index)            textureName.Sample(samplerName, float4(coord3, index))
+#define SAMPLE_TEXTURECUBE_ARRAY_LOD(textureName, samplerName, coord3, index, lod)   textureName.SampleLevel(samplerName, float4(coord3, index), lod)
-#define SAMPLE_TEXTURE3D(textureName, samplerName, coord3) textureName.Sample(samplerName, coord3)
-#define SAMPLE_TEXTURE2D_SHADOW(textureName, samplerName, coord3) textureName.SampleCmpLevelZero(samplerName, (coord3).xy, (coord3).z)
-#define SAMPLE_TEXTURE2D_ARRAY_SHADOW(textureName, samplerName, coord3, index) textureName.SampleCmpLevelZero(samplerName, float3((coord3).xy, index), (coord3).z)
-#define SAMPLE_TEXTURECUBE_SHADOW(textureName, samplerName, coord4) textureName.SampleCmpLevelZero(samplerName, (coord3).xyz, (coord3).w)
-#define SAMPLE_TEXTURECUBE_ARRAY_SHADOW(textureName, samplerName, coord4, index) textureName.SampleCmpLevelZero(samplerName, float4((coord4).xyz, index), (coord4).w)
+#define SAMPLE_TEXTURE3D(textureName, samplerName, coord3)                           textureName.Sample(samplerName, coord3)
+#define SAMPLE_TEXTURE3D_LOD(textureName, samplerName, coord3, lod) 				 textureName.SampleLevel(samplerName, coord3, lod)
-#define SAMPLE_DEPTH_TEXTURE(textureName, samplerName, coord2) SAMPLE_TEXTURE2D(textureName, samplerName, coord2).r
+#define SAMPLE_TEXTURE2D_SHADOW(textureName, samplerName, coord3)                    textureName.SampleCmpLevelZero(samplerName, (coord3).xy, (coord3).z)
+#define SAMPLE_TEXTURE2D_ARRAY_SHADOW(textureName, samplerName, coord3, index)       textureName.SampleCmpLevelZero(samplerName, float3((coord3).xy, index), (coord3).z)
+#define SAMPLE_TEXTURECUBE_SHADOW(textureName, samplerName, coord4)                  textureName.SampleCmpLevelZero(samplerName, (coord3).xyz, (coord3).w)
+#define SAMPLE_TEXTURECUBE_ARRAY_SHADOW(textureName, samplerName, coord4, index)     textureName.SampleCmpLevelZero(samplerName, float4((coord4).xyz, index), (coord4).w)
+
+#define SAMPLE_DEPTH_TEXTURE(textureName, samplerName, coord2)          SAMPLE_TEXTURE2D(textureName, samplerName, coord2).r
-#define TEXTURE2D_HALF TEXTURE2D
-#define TEXTURE2D_FLOAT TEXTURE2D
-#define TEXTURE3D_HALF TEXTURE3D
-#define TEXTURE3D_FLOAT TEXTURE3D
-#define SAMPLER2D_HALF SAMPLER2D
-#define SAMPLER2D_FLOAT SAMPLER2D
-
-#define LOAD_TEXTURE2D(textureName, unCoord2) textureName.Load(int3(unCoord2, 0))
-#define LOAD_TEXTURE2D_LOD(textureName, unCoord2, lod) textureName.Load(int3(unCoord2, lod))
-#define LOAD_TEXTURE2D_MSAA(textureName, unCoord2, sampleIndex) textureName.Load(unCoord2, sampleIndex)
-#define LOAD_TEXTURE2D_ARRAY(textureName, unCoord2, index) textureName.Load(int4(unCoord2, index, 0))
+#define LOAD_TEXTURE2D(textureName, unCoord2)                       textureName.Load(int3(unCoord2, 0))
+#define LOAD_TEXTURE2D_LOD(textureName, unCoord2, lod)              textureName.Load(int3(unCoord2, lod))
+#define LOAD_TEXTURE2D_MSAA(textureName, unCoord2, sampleIndex)     textureName.Load(unCoord2, sampleIndex)
+#define LOAD_TEXTURE2D_ARRAY(textureName, unCoord2, index)          textureName.Load(int4(unCoord2, index, 0))
-#define GATHER_TEXTURE2D(textureName, samplerName, coord2) textureName.Gather(samplerName, coord2)
-#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_TEXTURE2D(textureName, samplerName, coord2)                textureName.Gather(samplerName, coord2)
+#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_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

 
 // Texture abstraction
 
-#define TEXTURE2D(textureName) Texture2D textureName
-#define TEXTURE2D_ARRAY(textureName) Texture2DArray textureName
-#define TEXTURECUBE(textureName) TextureCube textureName
-#define TEXTURECUBE_ARRAY(textureName) TextureCubeArray textureName
-#define TEXTURE3D(textureName) Texture3D textureName
-#define RW_TEXTURE2D(type, textureName) RW_Texture2D<type> textureName
+#define TEXTURE2D(textureName)                Texture2D textureName
+#define TEXTURE2D_ARRAY(textureName)          Texture2DArray textureName
+#define TEXTURECUBE(textureName)              TextureCube textureName
+#define TEXTURECUBE_ARRAY(textureName)        TextureCubeArray textureName
+#define TEXTURE3D(textureName)                Texture3D textureName
+
+#define TEXTURE2D_SHADOW(textureName)         TEXTURE2D(textureName)
+#define TEXTURE2D_ARRAY_SHADOW(textureName)   TEXTURE2D_ARRAY(textureName)
+#define TEXTURECUBE_SHADOW(textureName)       TEXTURECUBE(textureName)
+#define TEXTURECUBE_ARRAY_SHADOW(textureName) TEXTURECUBE_ARRAY(textureName)
-#define SAMPLER2D(samplerName) SamplerState samplerName
-#define SAMPLERCUBE(samplerName) SamplerState samplerName
-#define SAMPLER3D(samplerName) SamplerState samplerName
-#define SAMPLER2D_SHADOW(samplerName) SamplerComparisonState samplerName
-#define SAMPLERCUBE_SHADOW(samplerName) SamplerComparisonState samplerName
+#define RW_TEXTURE2D(type, textureName)       RW_Texture2D<type> textureName
+#define RW_TEXTURE3D(type, textureName)       RW_Texture3D<type> textureName
+
+#define SAMPLER(samplerName)                  SamplerState samplerName
+#define SAMPLER_CMP(samplerName)              SamplerComparisonState samplerName
+
+#define TEXTURE2D_ARGS(textureName, samplerName)                 TEXTURE2D(textureName),         SAMPLER(samplerName)
+#define TEXTURE2D_ARRAY_ARGS(textureName, samplerName)           TEXTURE2D_ARRAY(textureName),   SAMPLER(samplerName)
+#define TEXTURECUBE_ARGS(textureName, samplerName)               TEXTURECUBE(textureName),       SAMPLER(samplerName)
+#define TEXTURECUBE_ARRAY_ARGS(textureName, samplerName)         TEXTURECUBE_ARRAY(textureName), SAMPLER(samplerName)
+#define TEXTURE3D_ARGS(textureName, samplerName)                 TEXTURE3D(textureName),         SAMPLER(samplerName)
+
+#define TEXTURE2D_SHADOW_ARGS(textureName, samplerName)          TEXTURE2D(textureName),         SAMPLER_CMP(samplerName)
+#define TEXTURE2D_ARRAY_SHADOW_ARGS(textureName, samplerName)    TEXTURE2D_ARRAY(textureName),   SAMPLER_CMP(samplerName)
+#define TEXTURECUBE_SHADOW_ARGS(textureName, samplerName)        TEXTURECUBE(textureName),       SAMPLER_CMP(samplerName)
+#define TEXTURECUBE_ARRAY_SHADOW_ARGS(textureName, samplerName)  TEXTURECUBE_ARRAY(textureName), SAMPLER_CMP(samplerName)
-#define TEXTURE2D_ARGS(textureName, samplerName) Texture2D textureName, SamplerState samplerName
-#define TEXTURE2D_ARRAY_ARGS(textureName, samplerName) Texture2DArray textureName, SamplerState samplerName
-#define TEXTURECUBE_ARGS(textureName, samplerName) TextureCube textureName, SamplerState samplerName
-#define TEXTURECUBE_ARRAY_ARGS(textureName, samplerName) TextureCubeArray textureName, SamplerState samplerName
-#define TEXTURE3D_ARGS(textureName, samplerName) Texture3D textureName, SamplerState samplerName
-#define TEXTURE2D_SHADOW_ARGS(textureName, samplerName) Texture2D textureName, SamplerComparisonState samplerName
-#define TEXTURE2D_ARRAY_SHADOW_ARGS(textureName, samplerName) Texture2DArray textureName, SamplerComparisonState samplerName
-#define TEXTURECUBE_SHADOW_ARGS(textureName, samplerName) TextureCube textureName, SamplerComparisonState samplerName
+#define TEXTURE2D_PARAM(textureName, samplerName)                textureName, samplerName
+#define TEXTURE2D_ARRAY_PARAM(textureName, samplerName)          textureName, samplerName
+#define TEXTURECUBE_PARAM(textureName, samplerName)              textureName, samplerName
+#define TEXTURECUBE_ARRAY_PARAM(textureName, samplerName)        textureName, samplerName
+#define TEXTURE3D_PARAM(textureName, samplerName)                textureName, samplerName
-#define TEXTURE2D_PARAM(textureName, samplerName) textureName, samplerName
-#define TEXTURE2D_ARRAY_PARAM(textureName, samplerName) textureName, samplerName
-#define TEXTURECUBE_PARAM(textureName, samplerName) textureName, samplerName
-#define TEXTURECUBE_ARRAY_PARAM(textureName, samplerName) textureName, samplerName
-#define TEXTURE3D_PARAM(textureName, samplerName) textureName, samplerName
-#define TEXTURE2D_SHADOW_PARAM(textureName, samplerName) textureName, samplerName
-#define TEXTURE2D_ARRAY_SHADOW_PARAM(textureName, samplerName) textureName, samplerName
-#define TEXTURECUBE_SHADOW_PARAM(textureName, samplerName) textureName, samplerName
+#define TEXTURE2D_SHADOW_PARAM(textureName, samplerName)         textureName, samplerName
+#define TEXTURE2D_ARRAY_SHADOW_PARAM(textureName, samplerName)   textureName, samplerName
+#define TEXTURECUBE_SHADOW_PARAM(textureName, samplerName)       textureName, samplerName
+#define TEXTURECUBE_ARRAY_SHADOW_PARAM(textureName, samplerName) textureName, samplerName
-#define SAMPLE_TEXTURE2D(textureName, samplerName, coord2) textureName.Sample(samplerName, coord2)
-#define SAMPLE_TEXTURE2D_LOD(textureName, samplerName, coord2, lod) textureName.SampleLevel(samplerName, coord2, lod)
-#define SAMPLE_TEXTURE2D_BIAS(textureName, samplerName, coord2, bias) textureName.SampleBias(samplerName, coord2, bias)
-#define SAMPLE_TEXTURE2D_GRAD(textureName, samplerName, coord2, ddx, ddy) textureName.SampleGrad(samplerName, coord2, ddx, ddy)
-#define SAMPLE_TEXTURE2D_ARRAY(textureName, samplerName, coord2, index) textureName.Sample(samplerName, float3(coord2, index))
-#define SAMPLE_TEXTURE2D_ARRAY_LOD(textureName, samplerName, coord2, index, lod) textureName.SampleLevel(samplerName, float3(coord2, index), lod)
-#define SAMPLE_TEXTURE2D_ARRAY_BIAS(textureName, samplerName, coord2, index, bias) textureName.SampleBias(samplerName, float3(coord2, index), bias)
-#define SAMPLE_TEXTURECUBE(textureName, samplerName, coord3) textureName.Sample(samplerName, coord3)
-#define SAMPLE_TEXTURECUBE_LOD(textureName, samplerName, coord3, lod) textureName.SampleLevel(samplerName, coord3, lod)
-#define SAMPLE_TEXTURECUBE_BIAS(textureName, samplerName, coord3, bias) textureName.SampleBias(samplerName, coord3, bias)
-#define SAMPLE_TEXTURECUBE_ARRAY(textureName, samplerName, coord3, index) textureName.Sample(samplerName, float4(coord3, index))
-#define SAMPLE_TEXTURECUBE_ARRAY_LOD(textureName, samplerName, coord3, index, lod) textureName.SampleLevel(samplerName, float4(coord3, index), lod)
+#define SAMPLE_TEXTURE2D(textureName, samplerName, coord2)                           textureName.Sample(samplerName, coord2)
+#define SAMPLE_TEXTURE2D_LOD(textureName, samplerName, coord2, lod)                  textureName.SampleLevel(samplerName, coord2, lod)
+#define SAMPLE_TEXTURE2D_BIAS(textureName, samplerName, coord2, bias)                textureName.SampleBias(samplerName, coord2, bias)
+#define SAMPLE_TEXTURE2D_GRAD(textureName, samplerName, coord2, dpdx, dpdy)          textureName.SampleGrad(samplerName, coord2, dpdx, dpdy)
+#define SAMPLE_TEXTURE2D_ARRAY(textureName, samplerName, coord2, index)              textureName.Sample(samplerName, float3(coord2, index))
+#define SAMPLE_TEXTURE2D_ARRAY_LOD(textureName, samplerName, coord2, index, lod)     textureName.SampleLevel(samplerName, float3(coord2, index), lod)
+#define SAMPLE_TEXTURE2D_ARRAY_BIAS(textureName, samplerName, coord2, index, bias)   textureName.SampleBias(samplerName, float3(coord2, index), bias)
+#define SAMPLE_TEXTURECUBE(textureName, samplerName, coord3)                         textureName.Sample(samplerName, coord3)
+#define SAMPLE_TEXTURECUBE_LOD(textureName, samplerName, coord3, lod)                textureName.SampleLevel(samplerName, coord3, lod)
+#define SAMPLE_TEXTURECUBE_BIAS(textureName, samplerName, coord3, bias)              textureName.SampleBias(samplerName, coord3, bias)
+#define SAMPLE_TEXTURECUBE_ARRAY(textureName, samplerName, coord3, index)            textureName.Sample(samplerName, float4(coord3, index))
+#define SAMPLE_TEXTURECUBE_ARRAY_LOD(textureName, samplerName, coord3, index, lod)   textureName.SampleLevel(samplerName, float4(coord3, index), lod)
-#define SAMPLE_TEXTURE3D(textureName, samplerName, coord3) textureName.Sample(samplerName, coord3)
-#define SAMPLE_TEXTURE2D_SHADOW(textureName, samplerName, coord3) textureName.SampleCmpLevelZero(samplerName, (coord3).xy, (coord3).z)
-#define SAMPLE_TEXTURE2D_ARRAY_SHADOW(textureName, samplerName, coord3, index) textureName.SampleCmpLevelZero(samplerName, float3((coord3).xy, index), (coord3).z)
-#define SAMPLE_TEXTURECUBE_SHADOW(textureName, samplerName, coord4) textureName.SampleCmpLevelZero(samplerName, (coord3).xyz, (coord3).w)
-#define SAMPLE_TEXTURECUBE_ARRAY_SHADOW(textureName, samplerName, coord4, index) textureName.SampleCmpLevelZero(samplerName, float4((coord4).xyz, index), (coord4).w)
+#define SAMPLE_TEXTURE3D(textureName, samplerName, coord3)                           textureName.Sample(samplerName, coord3)
+#define SAMPLE_TEXTURE3D_LOD(textureName, samplerName, coord3, lod) 				 textureName.SampleLevel(samplerName, coord3, lod)
-#define SAMPLE_DEPTH_TEXTURE(textureName, samplerName, coord2) SAMPLE_TEXTURE2D(textureName, samplerName, coord2).r
+#define SAMPLE_TEXTURE2D_SHADOW(textureName, samplerName, coord3)                    textureName.SampleCmpLevelZero(samplerName, (coord3).xy, (coord3).z)
+#define SAMPLE_TEXTURE2D_ARRAY_SHADOW(textureName, samplerName, coord3, index)       textureName.SampleCmpLevelZero(samplerName, float3((coord3).xy, index), (coord3).z)
+#define SAMPLE_TEXTURECUBE_SHADOW(textureName, samplerName, coord4)                  textureName.SampleCmpLevelZero(samplerName, (coord3).xyz, (coord3).w)
+#define SAMPLE_TEXTURECUBE_ARRAY_SHADOW(textureName, samplerName, coord4, index)     textureName.SampleCmpLevelZero(samplerName, float4((coord4).xyz, index), (coord4).w)
+
+#define SAMPLE_DEPTH_TEXTURE(textureName, samplerName, coord2)          SAMPLE_TEXTURE2D(textureName, samplerName, coord2).r
-#define TEXTURE2D_HALF TEXTURE2D
-#define TEXTURE2D_FLOAT TEXTURE2D
-#define TEXTURE3D_HALF TEXTURE3D
-#define TEXTURE3D_FLOAT TEXTURE3D
-#define SAMPLER2D_HALF SAMPLER2D
-#define SAMPLER2D_FLOAT SAMPLER2D
-
-#define LOAD_TEXTURE2D(textureName, unCoord2) textureName.Load(int3(unCoord2, 0))
-#define LOAD_TEXTURE2D_LOD(textureName, unCoord2, lod) textureName.Load(int3(unCoord2, lod))
-#define LOAD_TEXTURE2D_MSAA(textureName, unCoord2, sampleIndex) textureName.Load(unCoord2, sampleIndex)
-#define LOAD_TEXTURE2D_ARRAY(textureName, unCoord2, index) textureName.Load(int4(unCoord2, index, 0))
+#define LOAD_TEXTURE2D(textureName, unCoord2)                       textureName.Load(int3(unCoord2, 0))
+#define LOAD_TEXTURE2D_LOD(textureName, unCoord2, lod)              textureName.Load(int3(unCoord2, lod))
+#define LOAD_TEXTURE2D_MSAA(textureName, unCoord2, sampleIndex)     textureName.Load(unCoord2, sampleIndex)
+#define LOAD_TEXTURE2D_ARRAY(textureName, unCoord2, index)          textureName.Load(int4(unCoord2, index, 0))
-#define GATHER_TEXTURE2D(textureName, samplerName, coord2) textureName.Gather(samplerName, coord2)
-#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_TEXTURE2D(textureName, samplerName, coord2)                textureName.Gather(samplerName, coord2)
+#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_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

 
 // Texture abstraction
 
-#define TEXTURE2D(textureName) Texture2D textureName
-#define TEXTURE2D_ARRAY(textureName) Texture2DArray textureName
-#define TEXTURECUBE(textureName) TextureCube textureName
-#define TEXTURECUBE_ARRAY(textureName) TextureCubeArray textureName
-#define TEXTURE3D(textureName) Texture3D textureName
-#define RW_TEXTURE2D(type, textureName) RWTexture2D<type> textureName
+#define TEXTURE2D(textureName)                Texture2D textureName
+#define TEXTURE2D_ARRAY(textureName)          Texture2DArray textureName
+#define TEXTURECUBE(textureName)              TextureCube textureName
+#define TEXTURECUBE_ARRAY(textureName)        TextureCubeArray textureName
+#define TEXTURE3D(textureName)                Texture3D textureName
+
+#define TEXTURE2D_SHADOW(textureName)         TEXTURE2D(textureName)
+#define TEXTURE2D_ARRAY_SHADOW(textureName)   TEXTURE2D_ARRAY(textureName)
+#define TEXTURECUBE_SHADOW(textureName)       TEXTURECUBE(textureName)
+#define TEXTURECUBE_ARRAY_SHADOW(textureName) TEXTURECUBE_ARRAY(textureName)
-#define SAMPLER2D(samplerName) SamplerState samplerName
-#define SAMPLERCUBE(samplerName) SamplerState samplerName
-#define SAMPLER3D(samplerName) SamplerState samplerName
-#define SAMPLER2D_SHADOW(samplerName) SamplerComparisonState samplerName
-#define SAMPLERCUBE_SHADOW(samplerName) SamplerComparisonState samplerName
+#define RW_TEXTURE2D(type, textureName)       RWTexture2D<type> textureName
+#define RW_TEXTURE3D(type, textureName)       RWTexture3D<type> textureName
+
+#define SAMPLER(samplerName)                  SamplerState samplerName
+#define SAMPLER_CMP(samplerName)              SamplerComparisonState samplerName
+
+#define TEXTURE2D_ARGS(textureName, samplerName)                 TEXTURE2D(textureName),         SAMPLER(samplerName)
+#define TEXTURE2D_ARRAY_ARGS(textureName, samplerName)           TEXTURE2D_ARRAY(textureName),   SAMPLER(samplerName)
+#define TEXTURECUBE_ARGS(textureName, samplerName)               TEXTURECUBE(textureName),       SAMPLER(samplerName)
+#define TEXTURECUBE_ARRAY_ARGS(textureName, samplerName)         TEXTURECUBE_ARRAY(textureName), SAMPLER(samplerName)
+#define TEXTURE3D_ARGS(textureName, samplerName)                 TEXTURE3D(textureName),         SAMPLER(samplerName)
+
+#define TEXTURE2D_SHADOW_ARGS(textureName, samplerName)          TEXTURE2D(textureName),         SAMPLER_CMP(samplerName)
+#define TEXTURE2D_ARRAY_SHADOW_ARGS(textureName, samplerName)    TEXTURE2D_ARRAY(textureName),   SAMPLER_CMP(samplerName)
+#define TEXTURECUBE_SHADOW_ARGS(textureName, samplerName)        TEXTURECUBE(textureName),       SAMPLER_CMP(samplerName)
+#define TEXTURECUBE_ARRAY_SHADOW_ARGS(textureName, samplerName)  TEXTURECUBE_ARRAY(textureName), SAMPLER_CMP(samplerName)
-#define TEXTURE2D_ARGS(textureName, samplerName) Texture2D textureName, SamplerState samplerName
-#define TEXTURE2D_ARRAY_ARGS(textureName, samplerName) Texture2DArray textureName, SamplerState samplerName
-#define TEXTURECUBE_ARGS(textureName, samplerName) TextureCube textureName, SamplerState samplerName
-#define TEXTURECUBE_ARRAY_ARGS(textureName, samplerName) TextureCubeArray textureName, SamplerState samplerName
-#define TEXTURE3D_ARGS(textureName, samplerName) Texture3D textureName, SamplerState samplerName
-#define TEXTURE2D_SHADOW_ARGS(textureName, samplerName) Texture2D textureName, SamplerComparisonState samplerName
-#define TEXTURE2D_ARRAY_SHADOW_ARGS(textureName, samplerName) Texture2DArray textureName, SamplerComparisonState samplerName
-#define TEXTURECUBE_SHADOW_ARGS(textureName, samplerName) TextureCube textureName, SamplerComparisonState samplerName
+#define TEXTURE2D_PARAM(textureName, samplerName)                textureName, samplerName
+#define TEXTURE2D_ARRAY_PARAM(textureName, samplerName)          textureName, samplerName
+#define TEXTURECUBE_PARAM(textureName, samplerName)              textureName, samplerName
+#define TEXTURECUBE_ARRAY_PARAM(textureName, samplerName)        textureName, samplerName
+#define TEXTURE3D_PARAM(textureName, samplerName)                textureName, samplerName
-#define TEXTURE2D_PARAM(textureName, samplerName) textureName, samplerName
-#define TEXTURE2D_ARRAY_PARAM(textureName, samplerName) textureName, samplerName
-#define TEXTURECUBE_PARAM(textureName, samplerName) textureName, samplerName
-#define TEXTURECUBE_ARRAY_PARAM(textureName, samplerName) textureName, samplerName
-#define TEXTURE3D_PARAM(textureName, samplerName) textureName, samplerName
-#define TEXTURE2D_SHADOW_PARAM(textureName, samplerName) textureName, samplerName
-#define TEXTURE2D_ARRAY_SHADOW_PARAM(textureName, samplerName) textureName, samplerName
-#define TEXTURECUBE_SHADOW_PARAM(textureName, samplerName) textureName, samplerName
+#define TEXTURE2D_SHADOW_PARAM(textureName, samplerName)         textureName, samplerName
+#define TEXTURE2D_ARRAY_SHADOW_PARAM(textureName, samplerName)   textureName, samplerName
+#define TEXTURECUBE_SHADOW_PARAM(textureName, samplerName)       textureName, samplerName
+#define TEXTURECUBE_ARRAY_SHADOW_PARAM(textureName, samplerName) textureName, samplerName
-#define SAMPLE_TEXTURE2D(textureName, samplerName, coord2) textureName.Sample(samplerName, coord2)
-#define SAMPLE_TEXTURE2D_LOD(textureName, samplerName, coord2, lod) textureName.SampleLevel(samplerName, coord2, lod)
-#define SAMPLE_TEXTURE2D_BIAS(textureName, samplerName, coord2, bias) textureName.SampleBias(samplerName, coord2, bias)
-#define SAMPLE_TEXTURE2D_GRAD(textureName, samplerName, coord2, ddx, ddy) textureName.SampleGrad(samplerName, coord2, ddx, ddy)
-#define SAMPLE_TEXTURE2D_ARRAY(textureName, samplerName, coord2, index) textureName.Sample(samplerName, float3(coord2, index))
-#define SAMPLE_TEXTURE2D_ARRAY_LOD(textureName, samplerName, coord2, index, lod) textureName.SampleLevel(samplerName, float3(coord2, index), lod)
-#define SAMPLE_TEXTURE2D_ARRAY_BIAS(textureName, samplerName, coord2, index, bias) textureName.SampleBias(samplerName, float3(coord2, index), bias)
-#define SAMPLE_TEXTURECUBE(textureName, samplerName, coord3) textureName.Sample(samplerName, coord3)
-#define SAMPLE_TEXTURECUBE_LOD(textureName, samplerName, coord3, lod) textureName.SampleLevel(samplerName, coord3, lod)
-#define SAMPLE_TEXTURECUBE_BIAS(textureName, samplerName, coord3, bias) textureName.SampleBias(samplerName, coord3, bias)
-#define SAMPLE_TEXTURECUBE_ARRAY(textureName, samplerName, coord3, index) textureName.Sample(samplerName, float4(coord3, index))
-#define SAMPLE_TEXTURECUBE_ARRAY_LOD(textureName, samplerName, coord3, index, lod) textureName.SampleLevel(samplerName, float4(coord3, index), lod)
+#define SAMPLE_TEXTURE2D(textureName, samplerName, coord2)                           textureName.Sample(samplerName, coord2)
+#define SAMPLE_TEXTURE2D_LOD(textureName, samplerName, coord2, lod)                  textureName.SampleLevel(samplerName, coord2, lod)
+#define SAMPLE_TEXTURE2D_BIAS(textureName, samplerName, coord2, bias)                textureName.SampleBias(samplerName, coord2, bias)
+#define SAMPLE_TEXTURE2D_GRAD(textureName, samplerName, coord2, dpdx, dpdy)          textureName.SampleGrad(samplerName, coord2, dpdx, dpdy)
+#define SAMPLE_TEXTURE2D_ARRAY(textureName, samplerName, coord2, index)              textureName.Sample(samplerName, float3(coord2, index))
+#define SAMPLE_TEXTURE2D_ARRAY_LOD(textureName, samplerName, coord2, index, lod)     textureName.SampleLevel(samplerName, float3(coord2, index), lod)
+#define SAMPLE_TEXTURE2D_ARRAY_BIAS(textureName, samplerName, coord2, index, bias)   textureName.SampleBias(samplerName, float3(coord2, index), bias)
+#define SAMPLE_TEXTURECUBE(textureName, samplerName, coord3)                         textureName.Sample(samplerName, coord3)
+#define SAMPLE_TEXTURECUBE_LOD(textureName, samplerName, coord3, lod)                textureName.SampleLevel(samplerName, coord3, lod)
+#define SAMPLE_TEXTURECUBE_BIAS(textureName, samplerName, coord3, bias)              textureName.SampleBias(samplerName, coord3, bias)
+#define SAMPLE_TEXTURECUBE_ARRAY(textureName, samplerName, coord3, index)            textureName.Sample(samplerName, float4(coord3, index))
+#define SAMPLE_TEXTURECUBE_ARRAY_LOD(textureName, samplerName, coord3, index, lod)   textureName.SampleLevel(samplerName, float4(coord3, index), lod)
-#define SAMPLE_TEXTURE3D(textureName, samplerName, coord3) textureName.Sample(samplerName, coord3)
-#define SAMPLE_TEXTURE2D_SHADOW(textureName, samplerName, coord3) textureName.SampleCmpLevelZero(samplerName, (coord3).xy, (coord3).z)
-#define SAMPLE_TEXTURE2D_ARRAY_SHADOW(textureName, samplerName, coord3, index) textureName.SampleCmpLevelZero(samplerName, float3((coord3).xy, index), (coord3).z)
-#define SAMPLE_TEXTURECUBE_SHADOW(textureName, samplerName, coord4) textureName.SampleCmpLevelZero(samplerName, (coord3).xyz, (coord3).w)
-#define SAMPLE_TEXTURECUBE_ARRAY_SHADOW(textureName, samplerName, coord4, index) textureName.SampleCmpLevelZero(samplerName, float4((coord4).xyz, index), (coord4).w)
+#define SAMPLE_TEXTURE3D(textureName, samplerName, coord3)                           textureName.Sample(samplerName, coord3)
+#define SAMPLE_TEXTURE3D_LOD(textureName, samplerName, coord3, lod) 				 textureName.SampleLevel(samplerName, coord3, lod)
-#define SAMPLE_DEPTH_TEXTURE(textureName, samplerName, coord2) SAMPLE_TEXTURE2D(textureName, samplerName, coord2).r
+#define SAMPLE_TEXTURE2D_SHADOW(textureName, samplerName, coord3)                    textureName.SampleCmpLevelZero(samplerName, (coord3).xy, (coord3).z)
+#define SAMPLE_TEXTURE2D_ARRAY_SHADOW(textureName, samplerName, coord3, index)       textureName.SampleCmpLevelZero(samplerName, float3((coord3).xy, index), (coord3).z)
+#define SAMPLE_TEXTURECUBE_SHADOW(textureName, samplerName, coord4)                  textureName.SampleCmpLevelZero(samplerName, (coord3).xyz, (coord3).w)
+#define SAMPLE_TEXTURECUBE_ARRAY_SHADOW(textureName, samplerName, coord4, index)     textureName.SampleCmpLevelZero(samplerName, float4((coord4).xyz, index), (coord4).w)
+
+#define SAMPLE_DEPTH_TEXTURE(textureName, samplerName, coord2)          SAMPLE_TEXTURE2D(textureName, samplerName, coord2).r
-#define TEXTURE2D_HALF TEXTURE2D
-#define TEXTURE2D_FLOAT TEXTURE2D
-#define TEXTURE3D_HALF TEXTURE3D
-#define TEXTURE3D_FLOAT TEXTURE3D
-#define SAMPLER2D_HALF SAMPLER2D
-#define SAMPLER2D_FLOAT SAMPLER2D
-
-#define LOAD_TEXTURE2D(textureName, unCoord2) textureName.Load(int3(unCoord2, 0))
-#define LOAD_TEXTURE2D_LOD(textureName, unCoord2, lod) textureName.Load(int3(unCoord2, lod))
-#define LOAD_TEXTURE2D_MSAA(textureName, unCoord2, sampleIndex) textureName.Load(unCoord2, sampleIndex)
-#define LOAD_TEXTURE2D_ARRAY(textureName, unCoord2, index) textureName.Load(int4(unCoord2, index, 0))
+#define LOAD_TEXTURE2D(textureName, unCoord2)                       textureName.Load(int3(unCoord2, 0))
+#define LOAD_TEXTURE2D_LOD(textureName, unCoord2, lod)              textureName.Load(int3(unCoord2, lod))
+#define LOAD_TEXTURE2D_MSAA(textureName, unCoord2, sampleIndex)     textureName.Load(unCoord2, sampleIndex)
+#define LOAD_TEXTURE2D_ARRAY(textureName, unCoord2, index)          textureName.Load(int4(unCoord2, index, 0))
-#define GATHER_TEXTURE2D(textureName, samplerName, coord2) textureName.Gather(samplerName, coord2)
-#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_TEXTURE2D(textureName, samplerName, coord2)                textureName.Gather(samplerName, coord2)
+#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_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

 
 // Texture abstraction
 
-#define TEXTURE2D(textureName) Texture2D textureName
-#define TEXTURE2D_ARRAY(textureName) Texture2DArray textureName
-#define TEXTURECUBE(textureName) TextureCube textureName
-#define TEXTURECUBE_ARRAY(textureName) TextureCubeArray textureName
-#define TEXTURE3D(textureName) Texture3D textureName
-#define RW_TEXTURE2D(type, textureName) RWTexture2D<type> textureName
+#define TEXTURE2D(textureName)                Texture2D textureName
+#define TEXTURE2D_ARRAY(textureName)          Texture2DArray textureName
+#define TEXTURECUBE(textureName)              TextureCube textureName
+#define TEXTURECUBE_ARRAY(textureName)        TextureCubeArray textureName
+#define TEXTURE3D(textureName)                Texture3D textureName
+
+#define TEXTURE2D_SHADOW(textureName)         TEXTURE2D(textureName)
+#define TEXTURE2D_ARRAY_SHADOW(textureName)   TEXTURE2D_ARRAY(textureName)
+#define TEXTURECUBE_SHADOW(textureName)       TEXTURECUBE(textureName)
+#define TEXTURECUBE_ARRAY_SHADOW(textureName) TEXTURECUBE_ARRAY(textureName)
-#define SAMPLER2D(samplerName) SamplerState samplerName
-#define SAMPLERCUBE(samplerName) SamplerState samplerName
-#define SAMPLER3D(samplerName) SamplerState samplerName
-#define SAMPLER2D_SHADOW(samplerName) SamplerComparisonState samplerName
-#define SAMPLERCUBE_SHADOW(samplerName) SamplerComparisonState samplerName
+#define RW_TEXTURE2D(type, textureName)       RWTexture2D<type> textureName
+#define RW_TEXTURE3D(type, textureName)       RWTexture3D<type> textureName
+
+#define SAMPLER(samplerName)                  SamplerState samplerName
+#define SAMPLER_CMP(samplerName)              SamplerComparisonState samplerName
+
+#define TEXTURE2D_ARGS(textureName, samplerName)                 TEXTURE2D(textureName),         SAMPLER(samplerName)
+#define TEXTURE2D_ARRAY_ARGS(textureName, samplerName)           TEXTURE2D_ARRAY(textureName),   SAMPLER(samplerName)
+#define TEXTURECUBE_ARGS(textureName, samplerName)               TEXTURECUBE(textureName),       SAMPLER(samplerName)
+#define TEXTURECUBE_ARRAY_ARGS(textureName, samplerName)         TEXTURECUBE_ARRAY(textureName), SAMPLER(samplerName)
+#define TEXTURE3D_ARGS(textureName, samplerName)                 TEXTURE3D(textureName),         SAMPLER(samplerName)
+
+#define TEXTURE2D_SHADOW_ARGS(textureName, samplerName)          TEXTURE2D(textureName),         SAMPLER_CMP(samplerName)
+#define TEXTURE2D_ARRAY_SHADOW_ARGS(textureName, samplerName)    TEXTURE2D_ARRAY(textureName),   SAMPLER_CMP(samplerName)
+#define TEXTURECUBE_SHADOW_ARGS(textureName, samplerName)        TEXTURECUBE(textureName),       SAMPLER_CMP(samplerName)
+#define TEXTURECUBE_ARRAY_SHADOW_ARGS(textureName, samplerName)  TEXTURECUBE_ARRAY(textureName), SAMPLER_CMP(samplerName)
-#define TEXTURE2D_ARGS(textureName, samplerName) Texture2D textureName, SamplerState samplerName
-#define TEXTURE2D_ARRAY_ARGS(textureName, samplerName) Texture2DArray textureName, SamplerState samplerName
-#define TEXTURECUBE_ARGS(textureName, samplerName) TextureCube textureName, SamplerState samplerName
-#define TEXTURECUBE_ARRAY_ARGS(textureName, samplerName) TextureCubeArray textureName, SamplerState samplerName
-#define TEXTURE3D_ARGS(textureName, samplerName) Texture3D textureName, SamplerState samplerName
-#define TEXTURE2D_SHADOW_ARGS(textureName, samplerName) Texture2D textureName, SamplerComparisonState samplerName
-#define TEXTURE2D_ARRAY_SHADOW_ARGS(textureName, samplerName) Texture2DArray textureName, SamplerComparisonState samplerName
-#define TEXTURECUBE_SHADOW_ARGS(textureName, samplerName) TextureCube textureName, SamplerComparisonState samplerName
+#define TEXTURE2D_PARAM(textureName, samplerName)                textureName, samplerName
+#define TEXTURE2D_ARRAY_PARAM(textureName, samplerName)          textureName, samplerName
+#define TEXTURECUBE_PARAM(textureName, samplerName)              textureName, samplerName
+#define TEXTURECUBE_ARRAY_PARAM(textureName, samplerName)        textureName, samplerName
+#define TEXTURE3D_PARAM(textureName, samplerName)                textureName, samplerName
-#define TEXTURE2D_PARAM(textureName, samplerName) textureName, samplerName
-#define TEXTURE2D_ARRAY_PARAM(textureName, samplerName) textureName, samplerName
-#define TEXTURECUBE_PARAM(textureName, samplerName) textureName, samplerName
-#define TEXTURECUBE_ARRAY_PARAM(textureName, samplerName) textureName, samplerName
-#define TEXTURE3D_PARAM(textureName, samplerName) textureName, samplerName
-#define TEXTURE2D_SHADOW_PARAM(textureName, samplerName) textureName, samplerName
-#define TEXTURE2D_ARRAY_SHADOW_PARAM(textureName, samplerName) textureName, samplerName
-#define TEXTURECUBE_SHADOW_PARAM(textureName, samplerName) textureName, samplerName
+#define TEXTURE2D_SHADOW_PARAM(textureName, samplerName)         textureName, samplerName
+#define TEXTURE2D_ARRAY_SHADOW_PARAM(textureName, samplerName)   textureName, samplerName
+#define TEXTURECUBE_SHADOW_PARAM(textureName, samplerName)       textureName, samplerName
+#define TEXTURECUBE_ARRAY_SHADOW_PARAM(textureName, samplerName) textureName, samplerName
-#define SAMPLE_TEXTURE2D(textureName, samplerName, coord2) textureName.Sample(samplerName, coord2)
-#define SAMPLE_TEXTURE2D_LOD(textureName, samplerName, coord2, lod) textureName.SampleLevel(samplerName, coord2, lod)
-#define SAMPLE_TEXTURE2D_BIAS(textureName, samplerName, coord2, bias) textureName.SampleBias(samplerName, coord2, bias)
-#define SAMPLE_TEXTURE2D_GRAD(textureName, samplerName, coord2, ddx, ddy) textureName.SampleGrad(samplerName, coord2, ddx, ddy)
-#define SAMPLE_TEXTURE2D_ARRAY(textureName, samplerName, coord2, index) textureName.Sample(samplerName, float3(coord2, index))
-#define SAMPLE_TEXTURE2D_ARRAY_LOD(textureName, samplerName, coord2, index, lod) textureName.SampleLevel(samplerName, float3(coord2, index), lod)
-#define SAMPLE_TEXTURE2D_ARRAY_BIAS(textureName, samplerName, coord2, index, bias) textureName.SampleBias(samplerName, float3(coord2, index), bias)
-#define SAMPLE_TEXTURECUBE(textureName, samplerName, coord3) textureName.Sample(samplerName, coord3)
-#define SAMPLE_TEXTURECUBE_LOD(textureName, samplerName, coord3, lod) textureName.SampleLevel(samplerName, coord3, lod)
-#define SAMPLE_TEXTURECUBE_BIAS(textureName, samplerName, coord3, bias) textureName.SampleBias(samplerName, coord3, bias)
-#define SAMPLE_TEXTURECUBE_ARRAY(textureName, samplerName, coord3, index) textureName.Sample(samplerName, float4(coord3, index))
-#define SAMPLE_TEXTURECUBE_ARRAY_LOD(textureName, samplerName, coord3, index, lod) textureName.SampleLevel(samplerName, float4(coord3, index), lod)
+#define SAMPLE_TEXTURE2D(textureName, samplerName, coord2)                           textureName.Sample(samplerName, coord2)
+#define SAMPLE_TEXTURE2D_LOD(textureName, samplerName, coord2, lod)                  textureName.SampleLevel(samplerName, coord2, lod)
+#define SAMPLE_TEXTURE2D_BIAS(textureName, samplerName, coord2, bias)                textureName.SampleBias(samplerName, coord2, bias)
+#define SAMPLE_TEXTURE2D_GRAD(textureName, samplerName, coord2, dpdx, dpdy)          textureName.SampleGrad(samplerName, coord2, dpdx, dpdy)
+#define SAMPLE_TEXTURE2D_ARRAY(textureName, samplerName, coord2, index)              textureName.Sample(samplerName, float3(coord2, index))
+#define SAMPLE_TEXTURE2D_ARRAY_LOD(textureName, samplerName, coord2, index, lod)     textureName.SampleLevel(samplerName, float3(coord2, index), lod)
+#define SAMPLE_TEXTURE2D_ARRAY_BIAS(textureName, samplerName, coord2, index, bias)   textureName.SampleBias(samplerName, float3(coord2, index), bias)
+#define SAMPLE_TEXTURECUBE(textureName, samplerName, coord3)                         textureName.Sample(samplerName, coord3)
+#define SAMPLE_TEXTURECUBE_LOD(textureName, samplerName, coord3, lod)                textureName.SampleLevel(samplerName, coord3, lod)
+#define SAMPLE_TEXTURECUBE_BIAS(textureName, samplerName, coord3, bias)              textureName.SampleBias(samplerName, coord3, bias)
+#define SAMPLE_TEXTURECUBE_ARRAY(textureName, samplerName, coord3, index)            textureName.Sample(samplerName, float4(coord3, index))
+#define SAMPLE_TEXTURECUBE_ARRAY_LOD(textureName, samplerName, coord3, index, lod)   textureName.SampleLevel(samplerName, float4(coord3, index), lod)
-#define SAMPLE_TEXTURE3D(textureName, samplerName, coord3) textureName.Sample(samplerName, coord3)
-#define SAMPLE_TEXTURE2D_SHADOW(textureName, samplerName, coord3) textureName.SampleCmpLevelZero(samplerName, (coord3).xy, (coord3).z)
-#define SAMPLE_TEXTURE2D_ARRAY_SHADOW(textureName, samplerName, coord3, index) textureName.SampleCmpLevelZero(samplerName, float3((coord3).xy, index), (coord3).z)
-#define SAMPLE_TEXTURECUBE_SHADOW(textureName, samplerName, coord4) textureName.SampleCmpLevelZero(samplerName, (coord3).xyz, (coord3).w)
-#define SAMPLE_TEXTURECUBE_ARRAY_SHADOW(textureName, samplerName, coord4, index) textureName.SampleCmpLevelZero(samplerName, float4((coord4).xyz, index), (coord4).w)
+#define SAMPLE_TEXTURE3D(textureName, samplerName, coord3)                           textureName.Sample(samplerName, coord3)
+#define SAMPLE_TEXTURE3D_LOD(textureName, samplerName, coord3, lod) 				 textureName.SampleLevel(samplerName, coord3, lod)
-#define SAMPLE_DEPTH_TEXTURE(textureName, samplerName, coord2) SAMPLE_TEXTURE2D(textureName, samplerName, coord2).r
+#define SAMPLE_TEXTURE2D_SHADOW(textureName, samplerName, coord3)                    textureName.SampleCmpLevelZero(samplerName, (coord3).xy, (coord3).z)
+#define SAMPLE_TEXTURE2D_ARRAY_SHADOW(textureName, samplerName, coord3, index)       textureName.SampleCmpLevelZero(samplerName, float3((coord3).xy, index), (coord3).z)
+#define SAMPLE_TEXTURECUBE_SHADOW(textureName, samplerName, coord4)                  textureName.SampleCmpLevelZero(samplerName, (coord3).xyz, (coord3).w)
+#define SAMPLE_TEXTURECUBE_ARRAY_SHADOW(textureName, samplerName, coord4, index)     textureName.SampleCmpLevelZero(samplerName, float4((coord4).xyz, index), (coord4).w)
+
+#define SAMPLE_DEPTH_TEXTURE(textureName, samplerName, coord2)          SAMPLE_TEXTURE2D(textureName, samplerName, coord2).r
-#define TEXTURE2D_HALF TEXTURE2D
-#define TEXTURE2D_FLOAT TEXTURE2D
-#define TEXTURE3D_HALF TEXTURE3D
-#define TEXTURE3D_FLOAT TEXTURE3D
-#define SAMPLER2D_HALF SAMPLER2D
-#define SAMPLER2D_FLOAT SAMPLER2D
-
-#define LOAD_TEXTURE2D(textureName, unCoord2) textureName.Load(int3(unCoord2, 0))
-#define LOAD_TEXTURE2D_LOD(textureName, unCoord2, lod) textureName.Load(int3(unCoord2, lod))
-#define LOAD_TEXTURE2D_MSAA(textureName, unCoord2, sampleIndex) textureName.Load(unCoord2, sampleIndex)
-#define LOAD_TEXTURE2D_ARRAY(textureName, unCoord2, index) textureName.Load(int4(unCoord2, index, 0))
+#define LOAD_TEXTURE2D(textureName, unCoord2)                       textureName.Load(int3(unCoord2, 0))
+#define LOAD_TEXTURE2D_LOD(textureName, unCoord2, lod)              textureName.Load(int3(unCoord2, lod))
+#define LOAD_TEXTURE2D_MSAA(textureName, unCoord2, sampleIndex)     textureName.Load(unCoord2, sampleIndex)
+#define LOAD_TEXTURE2D_ARRAY(textureName, unCoord2, index)          textureName.Load(int4(unCoord2, index, 0))
-#define GATHER_TEXTURE2D(textureName, samplerName, coord2) textureName.Gather(samplerName, coord2)
-#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_TEXTURE2D(textureName, samplerName, coord2)                textureName.Gather(samplerName, coord2)
+#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_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/ShaderLibrary/Macros.hlsl

 // Some platform don't support cubemap array so we fallback on 2D latlong
 #ifdef  UNITY_NO_CUBEMAP_ARRAY
 #define TEXTURECUBE_ARRAY_ABSTRACT TEXTURE2D_ARRAY
-#define SAMPLERCUBE_ABSTRACT SAMPLER2D
-#define SAMPLERCUBE_ABSTRACT SAMPLERCUBE
 #define TEXTURECUBE_ARRAY_ARGS_ABSTRACT TEXTURECUBE_ARRAY_ARGS
 #define TEXTURECUBE_ARRAY_PARAM_ABSTRACT TEXTURECUBE_ARRAY_PARAM
 #define SAMPLE_TEXTURECUBE_ARRAY_LOD_ABSTRACT(textureName, samplerName, coord3, index, lod) SAMPLE_TEXTURECUBE_ARRAY_LOD(textureName, samplerName, coord3, index, lod)
 #define FLT_EPS     5.960464478e-8  // 2^-24, machine epsilon: 1 + EPS = 1 (half of the ULP for 1)
 #define FLT_MIN     1.175494351e-38 // Minimum representable positive floating-point number
 #define FLT_MAX     3.402823466e+38 // Maximum representable floating-point number
-#define FLT_NAN     asfloat(0xFFFFFFFF)
 #define HALF_MIN    6.103515625e-5  // 2^-14, the same value for 10, 11 and 16-bit: https://www.khronos.org/opengl/wiki/Small_Float_Formats
 #define HALF_MAX    65504.0
 #define UINT_MAX    0xFFFFFFFFu

ScriptableRenderPipeline/Core/ShaderLibrary/Wind.hlsl

 // Globals
 TEXTURE2D(WIND_SETTINGS_TexNoise);
-SAMPLER2D(sampler_WIND_SETTINGS_TexNoise);
+SAMPLER(sampler_WIND_SETTINGS_TexNoise);
-SAMPLER2D(sampler_WIND_SETTINGS_TexGust);
+SAMPLER(sampler_WIND_SETTINGS_TexGust);
 
 float4  WIND_SETTINGS_WorldDirectionAndSpeed;
 float   WIND_SETTINGS_FlexNoiseScale;

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/Debug/DebugDisplayLatlong.shader

             #include "ShaderLibrary/ImageBasedLighting.hlsl"
 
             TEXTURECUBE(_InputCubemap);
-            SAMPLERCUBE(sampler_InputCubemap);
+            SAMPLER(sampler_InputCubemap);
             float _Mipmap;
 
             struct Attributes

ScriptableRenderPipeline/HDRenderPipeline/Debug/DebugFullScreen.shader

             #include "../ShaderVariables.hlsl"
 
             TEXTURE2D(_DebugFullScreenTexture);
-            SAMPLER2D(sampler_DebugFullScreenTexture);
+            SAMPLER(sampler_DebugFullScreenTexture);
             float _FullScreenDebugMode;
 
             struct Attributes

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

 
         // 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_LightLoop.Cleanup();
 
             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_InternalSSSAsset);
 
+            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())
             {
             {
                 hdCamera.SetupGlobalParams(cmd);
 
-                // 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());
             }
         }
 
 
             foreach (var camera in cameras)
             {
-            // This is the main command buffer used for the frame.
-            var cmd = CommandBufferPool.Get("");
+                // This is the main command buffer used for the frame.
+                var cmd = CommandBufferPool.Get("");
-            using (new ProfilingSample(cmd, "HDRenderPipeline::Render", GetSampler(CustomSamplerId.HDRenderPipelineRender)))
-            {
-            foreach (var material in m_MaterialList)
-                material.RenderInit(cmd);
+                using (new ProfilingSample(cmd, "HDRenderPipeline::Render", GetSampler(CustomSamplerId.HDRenderPipelineRender)))
+                {
+                    foreach (var material in m_MaterialList)
+                        material.RenderInit(cmd);
-            // Do anything we need to do upon a new frame.
-            m_LightLoop.NewFrame();
+                    // Do anything we need to do upon a new frame.
+                    m_LightLoop.NewFrame();
-            if (camera == null)
-            {
-                renderContext.Submit();
-                continue;
-            }
+                    if (camera == null)
+                    {
+                        renderContext.Submit();
+                        continue;
+                    }
-            // If we render a reflection view or a preview we should not display any debug information
-            // This need to be call before ApplyDebugDisplaySettings()
-            if (camera.cameraType == CameraType.Reflection || camera.cameraType == CameraType.Preview)
-            {
-                // Neutral allow to disable all debug settings
-                m_CurrentDebugDisplaySettings = s_NeutralDebugDisplaySettings;
-            }
-            else
-            {
-                m_CurrentDebugDisplaySettings = m_DebugDisplaySettings;
+                    // If we render a reflection view or a preview we should not display any debug information
+                    // This need to be call before ApplyDebugDisplaySettings()
+                    if (camera.cameraType == CameraType.Reflection || camera.cameraType == CameraType.Preview)
+                    {
+                        // Neutral allow to disable all debug settings
+                        m_CurrentDebugDisplaySettings = s_NeutralDebugDisplaySettings;
+                    }
+                    else
+                    {
+                        m_CurrentDebugDisplaySettings = m_DebugDisplaySettings;
-                using (new ProfilingSample(cmd, "Volume Update", GetSampler(CustomSamplerId.VolumeUpdate)))
-                {
-                    // TODO: Transform & layer should be configurable per camera
-                    VolumeManager.instance.Update(camera.transform, -1);
-                }
-            }
+                        using (new ProfilingSample(cmd, "Volume Update", GetSampler(CustomSamplerId.VolumeUpdate)))
+                        {
+                            // TODO: Transform & layer should be configurable per camera
+                            VolumeManager.instance.Update(camera.transform, -1);
+                        }
+                    }
-            ApplyDebugDisplaySettings(cmd);
+                    ApplyDebugDisplaySettings(cmd);
-            if (!m_IBLFilterGGX.IsInitialized())
-                m_IBLFilterGGX.Initialize(cmd);
+                    if (!m_IBLFilterGGX.IsInitialized())
+                        m_IBLFilterGGX.Initialize(cmd);
-            ScriptableCullingParameters cullingParams;
-            if (!CullResults.GetCullingParameters(camera, out cullingParams))
-            {
-                renderContext.Submit();
-                continue;
-            }
+                    ScriptableCullingParameters cullingParams;
+                    if (!CullResults.GetCullingParameters(camera, out cullingParams))
+                    {
+                        renderContext.Submit();
+                        continue;
+                    }
-            m_LightLoop.UpdateCullingParameters( ref cullingParams );
+                    m_LightLoop.UpdateCullingParameters( ref cullingParams );
-            // emit scene view UI
-            if (camera.cameraType == CameraType.SceneView)
-            {
-                ScriptableRenderContext.EmitWorldGeometryForSceneView(camera);
-            }
+                    // emit scene view UI
+                    if (camera.cameraType == CameraType.SceneView)
+                    {
+                        ScriptableRenderContext.EmitWorldGeometryForSceneView(camera);
+                    }
-            using (new ProfilingSample(cmd, "CullResults.Cull", GetSampler(CustomSamplerId.CullResultsCull)))
-            {
-                CullResults.Cull(ref cullingParams, renderContext,ref m_CullResults);
-            }
+                    using (new ProfilingSample(cmd, "CullResults.Cull", GetSampler(CustomSamplerId.CullResultsCull)))
+                    {
+                        CullResults.Cull(ref cullingParams, renderContext,ref m_CullResults);
+                    }
-            var postProcessLayer = camera.GetComponent<PostProcessLayer>();
-            var hdCamera = HDCamera.Get(camera, postProcessLayer, m_Asset.globalRenderingSettings, stereoActive);
-            m_LightLoop.UpdateRenderingPathState(hdCamera.useForwardOnly);
+                    var postProcessLayer = camera.GetComponent<PostProcessLayer>();
+                    var hdCamera = HDCamera.Get(camera, postProcessLayer, m_Asset.globalRenderingSettings, stereoActive);
+                    m_LightLoop.UpdateRenderingPathState(hdCamera.useForwardOnly);
-            Resize(camera);
+                    Resize(camera);
-            renderContext.SetupCameraProperties(camera);
+                    renderContext.SetupCameraProperties(camera);
-            PushGlobalParams(hdCamera, cmd, sssSettings);
+                    PushGlobalParams(hdCamera, cmd, sssSettings);
-            // TODO: Find a correct place to bind these material textures
-            // We have to bind the material specific global parameters in this mode
-            m_MaterialList.ForEach(material => material.Bind());
+                    // TODO: Find a correct place to bind these material textures
+                    // We have to bind the material specific global parameters in this mode
+                    m_MaterialList.ForEach(material => material.Bind());
-            var additionalCameraData = camera.GetComponent<HDAdditionalCameraData>();
-            if (additionalCameraData && additionalCameraData.renderingPath == RenderingPathHDRP.Unlit)
-            {
-                // TODO: Add another path dedicated to planar reflection / real time cubemap that implement simpler lighting
-                // It is up to the users to only send unlit object for this camera path
+                    var additionalCameraData = camera.GetComponent<HDAdditionalCameraData>();
+                    if (additionalCameraData && additionalCameraData.renderingPath == RenderingPathHDRP.Unlit)
+                    {
+                        // TODO: Add another path dedicated to planar reflection / real time cubemap that implement simpler lighting
+                        // It is up to the users to only send unlit object for this camera path
-                using (new ProfilingSample(cmd, "Forward", GetSampler(CustomSamplerId.Forward)))
-                {
-                    CoreUtils.SetRenderTarget(cmd, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT, ClearFlag.Color | ClearFlag.Depth);
-                    RenderOpaqueRenderList(m_CullResults, camera, renderContext, cmd, HDShaderPassNames.s_ForwardName);
+                        using (new ProfilingSample(cmd, "Forward", GetSampler(CustomSamplerId.Forward)))
+                        {
+                            CoreUtils.SetRenderTarget(cmd, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT, ClearFlag.Color | ClearFlag.Depth);
+                            RenderOpaqueRenderList(m_CullResults, camera, renderContext, cmd, HDShaderPassNames.s_ForwardName);
-                }
+                        }
+
+                        renderContext.ExecuteCommandBuffer(cmd);
+                        CommandBufferPool.Release(cmd);
+                        renderContext.Submit();
+                        continue;
+                    }
-                renderContext.ExecuteCommandBuffer(cmd);
-                CommandBufferPool.Release(cmd);
-                renderContext.Submit();
-                continue;
-            }
+                    // Note: Legacy Unity behave like this for ShadowMask
+                    // When you select ShadowMask in Lighting panel it recompile shaders on the fly with the SHADOW_MASK keyword.
+                    // However there is no C# function that we can query to know what mode have been select in Lighting Panel and it will be wrong anyway. Lighting Panel setup what will be the next bake mode. But until light is bake, it is wrong.
+                    // Currently to know if you need shadow mask you need to go through all visible lights (of CullResult), check the LightBakingOutput struct and look at lightmapBakeType/mixedLightingMode. If one light have shadow mask bake mode, then you need shadow mask features (i.e extra Gbuffer).
+                    // It mean that when we build a standalone player, if we detect a light with bake shadow mask, we generate all shader variant (with and without shadow mask) and at runtime, when a bake shadow mask light is visible, we dynamically allocate an extra GBuffer and switch the shader.
+                    // So the first thing to do is to go through all the light: PrepareLightsForGPU
+                    bool enableBakeShadowMask;
+                    using (new ProfilingSample(cmd, "TP_PrepareLightsForGPU", GetSampler(CustomSamplerId.TPPrepareLightsForGPU)))
+                    {
+                        enableBakeShadowMask = m_LightLoop.PrepareLightsForGPU(cmd, m_ShadowSettings, m_CullResults, camera);
+                    }
+                    ConfigureForShadowMask(enableBakeShadowMask, cmd);
-            // Note: Legacy Unity behave like this for ShadowMask
-            // When you select ShadowMask in Lighting panel it recompile shaders on the fly with the SHADOW_MASK keyword.
-            // However there is no C# function that we can query to know what mode have been select in Lighting Panel and it will be wrong anyway. Lighting Panel setup what will be the next bake mode. But until light is bake, it is wrong.
-            // Currently to know if you need shadow mask you need to go through all visible lights (of CullResult), check the LightBakingOutput struct and look at lightmapBakeType/mixedLightingMode. If one light have shadow mask bake mode, then you need shadow mask features (i.e extra Gbuffer).
-            // It mean that when we build a standalone player, if we detect a light with bake shadow mask, we generate all shader variant (with and without shadow mask) and at runtime, when a bake shadow mask light is visible, we dynamically allocate an extra GBuffer and switch the shader.
-            // So the first thing to do is to go through all the light: PrepareLightsForGPU
-            bool enableBakeShadowMask;
-            using (new ProfilingSample(cmd, "TP_PrepareLightsForGPU", GetSampler(CustomSamplerId.TPPrepareLightsForGPU)))
-            {
-                enableBakeShadowMask = m_LightLoop.PrepareLightsForGPU(cmd, m_ShadowSettings, m_CullResults, camera);
-            }
-            ConfigureForShadowMask(enableBakeShadowMask, cmd);
+	                InitAndClearBuffer(hdCamera, enableBakeShadowMask, cmd);
-            InitAndClearBuffer(hdCamera, enableBakeShadowMask, cmd);
+                    RenderDepthPrepass(m_CullResults, hdCamera, renderContext, cmd, true);
-            RenderDepthPrepass(m_CullResults, hdCamera, renderContext, cmd, true);
+                    RenderVelocity(m_CullResults, hdCamera, renderContext, cmd);
-            RenderVelocity(m_CullResults, hdCamera, renderContext, cmd);
+                    RenderDBuffer(hdCamera.cameraPos, renderContext, cmd);
-            RenderDBuffer(hdCamera.cameraPos, renderContext, cmd);
+                    RenderGBuffer(m_CullResults, hdCamera, renderContext, cmd);
-            RenderGBuffer(m_CullResults, hdCamera, renderContext, cmd);
+                    // 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);
-            // 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());
-            // Caution: We require sun light here as some skies use the sun light to render, it means that UpdateSkyEnvironment must be called after PrepareLightsForGPU.
-            // TODO: Try to arrange code so we can trigger this call earlier and use async compute here to run sky convolution during other passes (once we move convolution shader to compute).
-            UpdateSkyEnvironment(hdCamera, cmd);
+                    // Caution: We require sun light here as some skies use the sun light to render, it means that UpdateSkyEnvironment must be called after PrepareLightsForGPU.
+                    // TODO: Try to arrange code so we can trigger this call earlier and use async compute here to run sky convolution during other passes (once we move convolution shader to compute).
+                    UpdateSkyEnvironment(hdCamera, cmd);
-            RenderPyramidDepth(camera, cmd, renderContext, FullScreenDebugMode.DepthPyramid);
+                    RenderPyramidDepth(camera, cmd, renderContext, FullScreenDebugMode.DepthPyramid);
-            if (m_CurrentDebugDisplaySettings.IsDebugMaterialDisplayEnabled())
-            {
-                RenderDebugViewMaterial(m_CullResults, hdCamera, renderContext, cmd);
-            }
-            else
-            {
-                using (new ProfilingSample(cmd, "Render SSAO", GetSampler(CustomSamplerId.RenderSSAO)))
-                {
-                    // TODO: Everything here (SSAO, Shadow, Build light list, deferred shadow, material and light classification can be parallelize with Async compute)
-                    RenderSSAO(cmd, camera, renderContext, postProcessLayer);
-                }
+                    if (m_CurrentDebugDisplaySettings.IsDebugMaterialDisplayEnabled())
+                    {
+                        RenderDebugViewMaterial(m_CullResults, hdCamera, renderContext, cmd);
+                    }
+                    else
+                    {
+                        using (new ProfilingSample(cmd, "Render SSAO", GetSampler(CustomSamplerId.RenderSSAO)))
+                        {
+                            // TODO: Everything here (SSAO, Shadow, Build light list, deferred shadow, material and light classification can be parallelize with Async compute)
+                            RenderSSAO(cmd, camera, renderContext, postProcessLayer);
+                        }
-                bool enableAsyncCompute = m_LightLoop.IsAsyncEnabled();
-                GPUFence buildGPULightListsCompleteFence = new GPUFence();
-                if (enableAsyncCompute)
-                {
-                    GPUFence startFence = cmd.CreateGPUFence();
-                    renderContext.ExecuteCommandBuffer(cmd);
-                    CommandBufferPool.Release(cmd);
-                    cmd = CommandBufferPool.Get("");
+                        bool enableAsyncCompute = m_LightLoop.IsAsyncEnabled();
+                        GPUFence buildGPULightListsCompleteFence = new GPUFence();
+                        if (enableAsyncCompute)
+                        {
+                            GPUFence startFence = cmd.CreateGPUFence();
+                            renderContext.ExecuteCommandBuffer(cmd);
+                            CommandBufferPool.Release(cmd);
+                            cmd = CommandBufferPool.Get("");
-                }
+                        }
-                using (new ProfilingSample(cmd, "Render shadows", GetSampler(CustomSamplerId.RenderShadows)))
-                {
-                    m_LightLoop.RenderShadows(renderContext, cmd, m_CullResults);
-                    // TODO: check if statement below still apply
-                    renderContext.SetupCameraProperties(camera); // Need to recall SetupCameraProperties after RenderShadows as it modify our view/proj matrix
-                }
+                        using (new ProfilingSample(cmd, "Render shadows", GetSampler(CustomSamplerId.RenderShadows)))
+                        {
+                            m_LightLoop.RenderShadows(renderContext, cmd, m_CullResults);
+                            // TODO: check if statement below still apply
+                            renderContext.SetupCameraProperties(camera); // Need to recall SetupCameraProperties after RenderShadows as it modify our view/proj matrix
+                        }
-                using (new ProfilingSample(cmd, "Deferred directional shadows", GetSampler(CustomSamplerId.RenderDeferredDirectionalShadow)))
-                {
-                    cmd.ReleaseTemporaryRT(m_DeferredShadowBuffer);
-                    cmd.GetTemporaryRT(m_DeferredShadowBuffer, camera.pixelWidth, camera.pixelHeight, 0, FilterMode.Point, RenderTextureFormat.ARGB32, RenderTextureReadWrite.Linear, 1 , true);
-                    m_LightLoop.RenderDeferredDirectionalShadow(hdCamera, m_DeferredShadowBufferRT, GetDepthTexture(), cmd);
-                    PushFullScreenDebugTexture(cmd, m_DeferredShadowBuffer, hdCamera.camera, renderContext, FullScreenDebugMode.DeferredShadows);
-                }
+                        using (new ProfilingSample(cmd, "Deferred directional shadows", GetSampler(CustomSamplerId.RenderDeferredDirectionalShadow)))
+                        {
+                            cmd.ReleaseTemporaryRT(m_DeferredShadowBuffer);
+                            cmd.GetTemporaryRT(m_DeferredShadowBuffer, camera.pixelWidth, camera.pixelHeight, 0, FilterMode.Point, RenderTextureFormat.ARGB32, RenderTextureReadWrite.Linear, 1 , true);
+                            m_LightLoop.RenderDeferredDirectionalShadow(hdCamera, m_DeferredShadowBufferRT, GetDepthTexture(), cmd);
+                            PushFullScreenDebugTexture(cmd, m_DeferredShadowBuffer, hdCamera.camera, renderContext, FullScreenDebugMode.DeferredShadows);
+                        }
-  	            // TODO: Move this code inside LightLoop
-                if (m_LightLoop.GetFeatureVariantsEnabled())
-                {
-                    // For material classification we use compute shader and so can't read into the stencil, so prepare it.
-                    using (new ProfilingSample(cmd, "Clear and copy stencil texture", GetSampler(CustomSamplerId.ClearAndCopyStencilTexture)))
-                    {
-                        CoreUtils.SetRenderTarget(cmd, m_CameraStencilBufferCopyRT, ClearFlag.Color, CoreUtils.clearColorAllBlack);
+  	                    // TODO: Move this code inside LightLoop
+                        if (m_LightLoop.GetFeatureVariantsEnabled())
+                        {
+                            // For material classification we use compute shader and so can't read into the stencil, so prepare it.
+                            using (new ProfilingSample(cmd, "Clear and copy stencil texture", GetSampler(CustomSamplerId.ClearAndCopyStencilTexture)))
+                            {
+                                CoreUtils.SetRenderTarget(cmd, m_CameraStencilBufferCopyRT, ClearFlag.Color, CoreUtils.clearColorAllBlack);
-                        cmd.SetRandomWriteTarget(1, GetHTile());
-                        // In the material classification shader we will simply test is we are no lighting
-                        // Use ShaderPassID 1 => "Pass 1 - Write 1 if value different from stencilRef to output"
-                        CoreUtils.DrawFullScreen(cmd, m_CopyStencilForNoLighting, m_CameraStencilBufferCopyRT, m_CameraDepthStencilBufferRT, null, 1);
-                        cmd.ClearRandomWriteTargets();
-                    }
-                }
+                                // In the material classification shader we will simply test is we are no lighting
+                                // Use ShaderPassID 1 => "Pass 1 - Write 1 if value different from stencilRef to output"
+                                CoreUtils.DrawFullScreen(cmd, m_CopyStencilForNoLighting, m_CameraStencilBufferCopyRT, m_CameraDepthStencilBufferRT, null, 1);
+                                cmd.ClearRandomWriteTargets();
+                            }
+                        }
-                if (enableAsyncCompute)
-                {
-                    m_LightLoop.BuildGPULightListAsyncEnd(camera, cmd, buildGPULightListsCompleteFence);
-                }
-                else
-                {
-                    using (new ProfilingSample(cmd, "Build Light list", GetSampler(CustomSamplerId.BuildLightList)))
-                    {
+                        if (enableAsyncCompute)
+                        {
+                            m_LightLoop.BuildGPULightListAsyncEnd(camera, cmd, buildGPULightListsCompleteFence);
+                        }
+                        else
+                        {
+                            using (new ProfilingSample(cmd, "Build Light list", GetSampler(CustomSamplerId.BuildLightList)))
+                            {
-                    }
-                }
+                            }
+                        }
-                RenderDeferredLighting(hdCamera, cmd);
+                        RenderDeferredLighting(hdCamera, cmd);
-                RenderForward(m_CullResults, hdCamera, renderContext, cmd, ForwardPass.Opaque);
-                RenderForwardError(m_CullResults, camera, renderContext, cmd, ForwardPass.Opaque);
+                        RenderForward(m_CullResults, hdCamera, renderContext, cmd, ForwardPass.Opaque);
+                        RenderForwardError(m_CullResults, camera, renderContext, cmd, ForwardPass.Opaque);
-                // SSS pass here handle both SSS material from deferred and forward
-                SubsurfaceScatteringPass(hdCamera, cmd, sssSettings);
+                        // SSS pass here handle both SSS material from deferred and forward
+                        m_SSSBufferManager.SubsurfaceScatteringPass(hdCamera, cmd, sssSettings, m_CurrentDebugDisplaySettings,
+                                                                    m_CameraColorBufferRT, m_CameraSssDiffuseLightingBufferRT, m_CameraDepthStencilBufferRT, GetDepthTexture());
-                RenderSky(hdCamera, cmd);
+                        RenderSky(hdCamera, cmd);
-                // Render pre refraction objects
-                RenderForward(m_CullResults, hdCamera, renderContext, cmd, ForwardPass.PreRefraction);
-                RenderForwardError(m_CullResults, camera, renderContext, cmd, ForwardPass.PreRefraction);
+                        // Render pre refraction objects
+                        RenderForward(m_CullResults, hdCamera, renderContext, cmd, ForwardPass.PreRefraction);
+                        RenderForwardError(m_CullResults, camera, renderContext, cmd, ForwardPass.PreRefraction);
-                RenderGaussianPyramidColor(camera, cmd, renderContext, FullScreenDebugMode.PreRefractionColorPyramid);
+                        RenderGaussianPyramidColor(camera, cmd, renderContext, FullScreenDebugMode.PreRefractionColorPyramid);
-                // Render all type of transparent forward (unlit, lit, complex (hair...)) to keep the sorting between transparent objects.
-                RenderForward(m_CullResults, hdCamera, renderContext, cmd, ForwardPass.Transparent);
-                RenderForwardError(m_CullResults, camera, renderContext, cmd, ForwardPass.Transparent);
+                        // Render all type of transparent forward (unlit, lit, complex (hair...)) to keep the sorting between transparent objects.
+                        RenderForward(m_CullResults, hdCamera, renderContext, cmd, ForwardPass.Transparent);
+                        RenderForwardError(m_CullResults, camera, renderContext, cmd, ForwardPass.Transparent);
-                PushFullScreenDebugTexture(cmd, m_CameraColorBuffer, camera, renderContext, FullScreenDebugMode.NanTracker);
+                        PushFullScreenDebugTexture(cmd, m_CameraColorBuffer, camera, renderContext, FullScreenDebugMode.NanTracker);
-                // Planar and real time cubemap doesn't need post process and render in FP16
-                if (camera.cameraType == CameraType.Reflection)
-                {
-                    using (new ProfilingSample(cmd, "Blit to final RT", GetSampler(CustomSamplerId.BlitToFinalRT)))
-                    {
-                        // Simple blit
-                        cmd.Blit(m_CameraColorBufferRT, BuiltinRenderTextureType.CameraTarget);
-                    }
-                }
-                else
-                {
-                    RenderGaussianPyramidColor(camera, cmd, renderContext, FullScreenDebugMode.FinalColorPyramid);
+                        // Planar and real time cubemap doesn't need post process and render in FP16
+                        if (camera.cameraType == CameraType.Reflection)
+                        {
+                            using (new ProfilingSample(cmd, "Blit to final RT", GetSampler(CustomSamplerId.BlitToFinalRT)))
+                            {
+                                // Simple blit
+                                cmd.Blit(m_CameraColorBufferRT, BuiltinRenderTextureType.CameraTarget);
+                            }
+                        }
+                        else
+                        {
+                            RenderGaussianPyramidColor(camera, cmd, renderContext, FullScreenDebugMode.FinalColorPyramid);
-                    // TODO: Check with VFX team.
-                    // Rendering distortion here have off course lot of artifact.
-                    // But resolving at each objects that write in distortion is not possible (need to sort transparent, render those that do not distort, then resolve, then etc...)
-                    // Instead we chose to apply distortion at the end after we cumulate distortion vector and desired blurriness.
-                    AccumulateDistortion(m_CullResults, camera, renderContext, cmd);
-                    RenderDistortion(cmd, m_Asset.renderPipelineResources);
+                            // TODO: Check with VFX team.
+                            // Rendering distortion here have off course lot of artifact.
+                            // But resolving at each objects that write in distortion is not possible (need to sort transparent, render those that do not distort, then resolve, then etc...)
+                            // Instead we chose to apply distortion at the end after we cumulate distortion vector and desired blurriness.
+                            AccumulateDistortion(m_CullResults, camera, renderContext, cmd);
+                            RenderDistortion(cmd, m_Asset.renderPipelineResources);
-                    RenderPostProcesses(hdCamera, cmd, postProcessLayer);
-                }
-            }
+                            RenderPostProcesses(hdCamera, cmd, postProcessLayer);
+                        }
+                    }
-            RenderDebug(hdCamera, cmd);
+                    RenderDebug(hdCamera, cmd);
-            // Make sure to unbind every render texture here because in the next iteration of the loop we might have to reallocate render texture (if the camera size is different)
-            cmd.SetRenderTarget(new RenderTargetIdentifier(-1), new RenderTargetIdentifier(-1));
+                    // Make sure to unbind every render texture here because in the next iteration of the loop we might have to reallocate render texture (if the camera size is different)
+                    cmd.SetRenderTarget(new RenderTargetIdentifier(-1), new RenderTargetIdentifier(-1));
-            // We still need to bind correctly default camera target with our depth buffer in case we are currently rendering scene view. It should be the last camera here
+                    // We still need to bind correctly default camera target with our depth buffer in case we are currently rendering scene view. It should be the last camera here
-            // bind depth surface for editor grid/gizmo/selection rendering
-            if (camera.cameraType == CameraType.SceneView)
-                cmd.SetRenderTarget(BuiltinRenderTextureType.CameraTarget, m_CameraDepthStencilBufferRT);
+                    // bind depth surface for editor grid/gizmo/selection rendering
+                    if (camera.cameraType == CameraType.SceneView)
+                        cmd.SetRenderTarget(BuiltinRenderTextureType.CameraTarget, m_CameraDepthStencilBufferRT);
-            renderContext.ExecuteCommandBuffer(cmd);
+                renderContext.ExecuteCommandBuffer(cmd);
-            CommandBufferPool.Release(cmd);
-            renderContext.Submit();
+                CommandBufferPool.Release(cmd);
+                renderContext.Submit();
             } // For each camera
         }
 
                 }
             }
 
-                // Render transparent depth prepass after opaque one
+            // 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);
             }
         }
             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)
         {
             m_SkyManager.UpdateEnvironment(hdCamera,m_LightLoop.GetCurrentSunLight(), cmd);
                 var mipSize = size;
                 for (int i = 0; i < lodCount; i++)
                 {
+                    int srcMipSize = mipSize;
                     mipSize >>= 1;
 
                     cmd.ReleaseTemporaryRT(HDShaderIDs._DepthPyramidMips[i + 1]);
-                    cmd.SetComputeVectorParam(m_DepthPyramidCS, "_Size", new Vector4(mipSize, mipSize, 1f / mipSize, 1f / mipSize));
+                    cmd.SetComputeVectorParam(m_DepthPyramidCS, "_SrcSize", new Vector4(srcMipSize, srcMipSize, 1f / srcMipSize, 1f / srcMipSize));
                     cmd.DispatchCompute(m_DepthPyramidCS, m_DepthPyramidKernel, mipSize / 8, mipSize / 8, 1);
                     cmd.CopyTexture(HDShaderIDs._DepthPyramidMips[i + 1], 0, 0, m_DepthPyramidBufferRT, 0, i + 1);
                 }
             }
         }
 
-        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/LightEvaluation.hlsl

 //-----------------------------------------------------------------------------
 
 float3 EvaluateCookie_Directional(LightLoopContext lightLoopContext, DirectionalLightData lightData,
-                                  float3 lighToSample)
+                                  float3 positionWS)
-    // Compute the CS position (in [-1, 1]^2) by projecting 'positionWS' onto the near plane.
+
+    // Translate and rotate 'positionWS' into the light space.
-    float3x3 lightToWorld = float3x3(lightData.right, lightData.up, lightData.forward);
-    float3   positionLS   = mul(lighToSample, transpose(lightToWorld));
-    float2   positionCS   = positionLS.xy;
+    float3   lightToSample = positionWS - lightData.positionWS;
+    float3x3 lightToWorld  = float3x3(lightData.right, lightData.up, lightData.forward);
+    float3   positionLS    = mul(lightToSample, transpose(lightToWorld));
+
+    // Perform orthographic projection.
+    float2 positionCS    = positionLS.xy;
 
     // Remap the texture coordinates from [-1, 1]^2 to [0, 1]^2.
     float2 positionNDC = positionCS * 0.5 + 0.5;
 
     [branch] if (lightData.cookieIndex >= 0)
     {
-        float3 lightToSample = positionWS - lightData.positionWS;
-        float3 cookie = EvaluateCookie_Directional(lightLoopContext, lightData, lightToSample);
+        float3 cookie = EvaluateCookie_Directional(lightLoopContext, lightData, positionWS);
 
         color *= cookie;
     }
 //-----------------------------------------------------------------------------
 
 float4 EvaluateCookie_Punctual(LightLoopContext lightLoopContext, LightData lightData,
-                               float3 lighToSample)
+                               float3 positionWS)
-    float3x3 lightToWorld = float3x3(lightData.right, lightData.up, lightData.forward);
-    float3   positionLS   = mul(lighToSample, transpose(lightToWorld));
+    float3   lightToSample = positionWS - lightData.positionWS;
+    float3x3 lightToWorld  = float3x3(lightData.right, lightData.up, lightData.forward);
+    float3   positionLS    = mul(lightToSample, transpose(lightToWorld));
 
     float4 cookie;
 
     }
     else
     {
-        // Compute the NDC position (in [-1, 1]^2) by projecting 'positionWS' onto the plane at 1m distance.
-        // Box projector lights require no perspective division.
+        // Perform orthographic or perspective projection.
         float  perspectiveZ = (lightType != GPULIGHTTYPE_PROJECTOR_BOX) ? positionLS.z : 1.0;
         float2 positionCS   = positionLS.xy / perspectiveZ;
         bool   isInBounds   = Max3(abs(positionCS.x), abs(positionCS.y), 1.0 - positionLS.z) <= 1.0;
     // Projector lights always have cookies, so we can perform clipping inside the if().
     [branch] if (lightData.cookieIndex >= 0)
     {
-        float3 lightToSample = positionWS - lightData.positionWS;
-        float4 cookie = EvaluateCookie_Punctual(lightLoopContext, lightData, lightToSample);
+        float4 cookie = EvaluateCookie_Punctual(lightLoopContext, lightData, positionWS);
 
         color       *= cookie.rgb;
         attenuation *= cookie.a;

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/LightLoop/LightLoopDef.hlsl

 
 // Used by directional and spot lights
 TEXTURE2D_ARRAY(_CookieTextures);
-SAMPLER2D(sampler_CookieTextures);
-SAMPLERCUBE_ABSTRACT(sampler_CookieCubeTextures);
-SAMPLERCUBE_ABSTRACT(sampler_EnvTextures);
 
 TEXTURE2D(_DeferredShadowTexture);
 
 // Used by directional and spot lights.
 float3 SampleCookie2D(LightLoopContext lightLoopContext, float2 coord, int index)
 {
-    return SAMPLE_TEXTURE2D_ARRAY_LOD(_CookieTextures, sampler_CookieTextures, coord, index, 0).rgb;
+    // TODO: add MIP maps to combat aliasing?
+    return SAMPLE_TEXTURE2D_ARRAY_LOD(_CookieTextures, s_linear_clamp_sampler, coord, index, 0).rgb;
-    return SAMPLE_TEXTURECUBE_ARRAY_LOD_ABSTRACT(_CookieCubeTextures, sampler_CookieCubeTextures, coord, index, 0).rgb;
+    // TODO: add MIP maps to combat aliasing?
+    return SAMPLE_TEXTURECUBE_ARRAY_LOD_ABSTRACT(_CookieCubeTextures, s_linear_clamp_sampler, coord, index, 0).rgb;
 }
 
 //-----------------------------------------------------------------------------
     // This code will be inlined as lightLoopContext is hardcoded in the light loop
     if (lightLoopContext.sampleReflection == SINGLE_PASS_CONTEXT_SAMPLE_REFLECTION_PROBES)
     {
-        return SAMPLE_TEXTURECUBE_ARRAY_LOD_ABSTRACT(_EnvTextures, sampler_EnvTextures, texCoord, index, lod);
+        return SAMPLE_TEXTURECUBE_ARRAY_LOD_ABSTRACT(_EnvTextures, s_trilinear_clamp_sampler, texCoord, index, lod);
     }
     else // SINGLE_PASS_SAMPLE_SKY
     {

ScriptableRenderPipeline/HDRenderPipeline/Lighting/LightLoop/ShadowContext.hlsl

 #include "ShaderLibrary/Shadow/Shadow.hlsl"
 
 TEXTURE2D_ARRAY(_ShadowmapExp_VSM_0);
-SAMPLER2D(sampler_ShadowmapExp_VSM_0);
+SAMPLER(sampler_ShadowmapExp_VSM_0);
-SAMPLER2D(sampler_ShadowmapExp_VSM_1);
+SAMPLER(sampler_ShadowmapExp_VSM_1);
-SAMPLER2D(sampler_ShadowmapExp_VSM_2);
+SAMPLER(sampler_ShadowmapExp_VSM_2);
-SAMPLER2D_SHADOW(sampler_ShadowmapExp_PCF);
+SAMPLER_CMP(sampler_ShadowmapExp_PCF);
 
 StructuredBuffer<ShadowData>	_ShadowDatasExp;
 StructuredBuffer<int4>			_ShadowPayloads;

ScriptableRenderPipeline/HDRenderPipeline/Lighting/LightLoop/builddispatchindirect.compute

 #include "ShaderLibrary/Common.hlsl"
 #include "LightLoop.cs.hlsl"
 
+#include "../../ShaderVariables.hlsl"
 #define UNITY_MATERIAL_LIT // Need to be define before including Material.hlsl
 #include "../../Material/Material.hlsl" // This includes Material.hlsl
 

ScriptableRenderPipeline/HDRenderPipeline/Lighting/LightLoop/materialflags.compute

 #include "ShaderBase.hlsl"
 #include "LightLoop.cs.hlsl"
 
+#include "../../ShaderVariables.hlsl"
 #define UNITY_MATERIAL_LIT // Need to be define before including Material.hlsl
 #include "../../Material/Material.hlsl" // This includes Material.hlsl
 #include "../../Lighting/LightDefinition.cs.hlsl"

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/Decal/DecalProperties.hlsl

 
 
 TEXTURE2D(_BaseColorMap);
-SAMPLER2D(sampler_BaseColorMap);
+SAMPLER(sampler_BaseColorMap);
-SAMPLER2D(sampler_NormalMap);
+SAMPLER(sampler_NormalMap);
 
 float _DecalBlend;
 

ScriptableRenderPipeline/HDRenderPipeline/Material/GGXConvolution/BuildProbabilityTables.compute

 
 #include "ShaderLibrary/Common.hlsl"
 #include "ShaderLibrary/ImageBasedLighting.hlsl"
+#include "../../ShaderVariables.hlsl"
 
 /* --- Input --- */
 
 TEXTURECUBE(envMap);                      // Input cubemap
-SAMPLERCUBE(sampler_envMap);
 
 /* --- Output --- */
 
 
     float3 L1 = ConvertEquiarealToCubemap(u1, v);
     float3 L2 = ConvertEquiarealToCubemap(u2, v);
-    float3 c1 = SAMPLE_TEXTURECUBE_LOD(envMap, sampler_envMap, L1, 0).rgb;
-    float3 c2 = SAMPLE_TEXTURECUBE_LOD(envMap, sampler_envMap, L2, 0).rgb;
+    float3 c1 = SAMPLE_TEXTURECUBE_LOD(envMap, s_linear_clamp_sampler, L1, 0).rgb;
+    float3 c2 = SAMPLE_TEXTURECUBE_LOD(envMap, s_linear_clamp_sampler, L2, 0).rgb;
 
     // Compute the integral of the step function (row values).
     // TODO: process 4 texels per thread, and manually unroll.

ScriptableRenderPipeline/HDRenderPipeline/Material/GGXConvolution/GGXConvolve.shader

             #include "ShaderLibrary/Common.hlsl"
             #include "ShaderLibrary/ImageBasedLighting.hlsl"
             #include "GGXConvolution.cs.hlsl"
+            #include "../../ShaderVariables.hlsl"
-            SAMPLERCUBE(sampler_MainTex);
-            TEXTURE2D_FLOAT(_GgxIblSamples);
+            TEXTURE2D(_GgxIblSamples);
 
             #ifdef USE_MIS
                 TEXTURE2D(_MarginalRowDensities);
                 uint  sampleCount = GetIBLRuntimeFilterSampleCount(_Level);
 
             #ifdef USE_MIS
-                float4 val = IntegrateLD_MIS(TEXTURECUBE_PARAM(_MainTex, sampler_MainTex),
+                float4 val = IntegrateLD_MIS(TEXTURECUBE_PARAM(_MainTex, s_trilinear_clamp_sampler),
                                              _MarginalRowDensities, _ConditionalDensities,
                                              V, N,
                                              roughness,
                                              1024,
                                              false);
             #else
-                float4 val = IntegrateLD(TEXTURECUBE_PARAM(_MainTex, sampler_MainTex),
+                float4 val = IntegrateLD(TEXTURECUBE_PARAM(_MainTex, s_trilinear_clamp_sampler),
                                          _GgxIblSamples,
                                          V, N,
                                          roughness,

ScriptableRenderPipeline/HDRenderPipeline/Material/GGXConvolution/RuntimeFilterIBL.cs

         Matrix4x4[]   m_faceWorldToViewMatrixMatrices     = new Matrix4x4[6];
 
 
-        RenderPipelineResources m_RenderPipelinesResources;
+        RenderPipelineResources m_RenderPipelineResources;
-        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

 // #define LIT_DIFFUSE_LAMBERT_BRDF
 #define LIT_USE_GGX_ENERGY_COMPENSATION
 
-// Sampler use by area light, gaussian pyramid, ambient occlusion etc...
-SamplerState s_linear_clamp_sampler;
-SamplerState s_trilinear_clamp_sampler;
-
 // Rough refraction texture
 // Color pyramid (width, height, lodcount, Unused)
 TEXTURE2D(_GaussianPyramidColorTexture);
         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, 2u * surfaceData.subsurfaceProfile);
 
         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);
     {
         // Note: this is a ad-hoc tweak.
         // TODO: we need a better hack.
-        float iblPerceptualRoughness = bsdfData.perceptualRoughness * saturate(1.2 - bsdfData.anisotropy);
+        float iblPerceptualRoughness = bsdfData.perceptualRoughness * saturate(1.2 - abs(bsdfData.anisotropy));
         float iblRoughness           = PerceptualRoughnessToRoughness(iblPerceptualRoughness);
         preLightData.iblDirWS        = GetSpecularDominantDir(N, iblR, iblRoughness, NdotV);
         preLightData.iblMipLevel     = PerceptualRoughnessToMipmapLevel(iblPerceptualRoughness);
 #ifndef _SURFACE_TYPE_TRANSPARENT
 #define USE_DEFERRED_DIRECTIONAL_SHADOWS // Deferred shadows are always enabled for opaque objects
 #endif
+
+#include "../../Lighting/LightEvaluation.hlsl"
 
 //-----------------------------------------------------------------------------
 // Lighting structure for light accumulation
 // 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/LitProperties.hlsl

 // ===========================================================================
 
 TEXTURE2D(_DistortionVectorMap);
-SAMPLER2D(sampler_DistortionVectorMap);
+SAMPLER(sampler_DistortionVectorMap);
-SAMPLER2D(sampler_EmissiveColorMap);
+SAMPLER(sampler_EmissiveColorMap);
-SAMPLER2D(sampler_DiffuseLightingMap);
+SAMPLER(sampler_DiffuseLightingMap);
-SAMPLER2D(sampler_BaseColorMap);
+SAMPLER(sampler_BaseColorMap);
-SAMPLER2D(sampler_MaskMap);
+SAMPLER(sampler_MaskMap);
-SAMPLER2D(sampler_BentNormalMap);
+SAMPLER(sampler_BentNormalMap);
-SAMPLER2D(sampler_NormalMap);
+SAMPLER(sampler_NormalMap);
-SAMPLER2D(sampler_NormalMapOS);
+SAMPLER(sampler_NormalMapOS);
-SAMPLER2D(sampler_DetailMap);
+SAMPLER(sampler_DetailMap);
-SAMPLER2D(sampler_HeightMap);
+SAMPLER(sampler_HeightMap);
-SAMPLER2D(sampler_TangentMap);
+SAMPLER(sampler_TangentMap);
-SAMPLER2D(sampler_TangentMapOS);
+SAMPLER(sampler_TangentMapOS);
-SAMPLER2D(sampler_AnisotropyMap);
+SAMPLER(sampler_AnisotropyMap);
-SAMPLER2D(sampler_SubsurfaceRadiusMap);
+SAMPLER(sampler_SubsurfaceRadiusMap);
-SAMPLER2D(sampler_ThicknessMap);
+SAMPLER(sampler_ThicknessMap);
-SAMPLER2D(sampler_SpecularColorMap);
+SAMPLER(sampler_SpecularColorMap);
-SAMPLER2D(sampler_TransmittanceColorMap);
+SAMPLER(sampler_TransmittanceColorMap);
 
 #else
 
 // mean we must declare all sampler
 #define PROP_DECL_TEX2D(name)\
     TEXTURE2D(MERGE_NAME(name, 0)); \
-    SAMPLER2D(MERGE_NAME(MERGE_NAME(sampler, name), 0)); \
+    SAMPLER(MERGE_NAME(MERGE_NAME(sampler, name), 0)); \
-    SAMPLER2D(MERGE_NAME(MERGE_NAME(sampler, name), 1)); \
+    SAMPLER(MERGE_NAME(MERGE_NAME(sampler, name), 1)); \
-    SAMPLER2D(MERGE_NAME(MERGE_NAME(sampler, name), 2)); \
+    SAMPLER(MERGE_NAME(MERGE_NAME(sampler, name), 2)); \
-    SAMPLER2D(MERGE_NAME(MERGE_NAME(sampler, name), 3))
+    SAMPLER(MERGE_NAME(MERGE_NAME(sampler, name), 3))
 
 
 PROP_DECL_TEX2D(_BaseColorMap);
 PROP_DECL_TEX2D(_ThicknessMap);
 
 TEXTURE2D(_LayerMaskMap);
-SAMPLER2D(sampler_LayerMaskMap);
+SAMPLER(sampler_LayerMaskMap);
-SAMPLER2D(sampler_LayerInfluenceMaskMap);
+SAMPLER(sampler_LayerInfluenceMaskMap);
 
 #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/Material.hlsl

 
 #include "Builtin/BuiltinData.hlsl"
 
-#if defined(LIGHTLOOP_SINGLE_PASS) || defined(LIGHTLOOP_TILE_PASS)
-#include "../Lighting/LightEvaluation.hlsl" // Depends on LightLoopDef and BuiltinData, shared by different materials and light loops
-#endif
-
 //-----------------------------------------------------------------------------
 // Material definition
 //-----------------------------------------------------------------------------

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/Material/Unlit/UnlitProperties.hlsl

 float4  _UnlitColor;
 TEXTURE2D(_UnlitColorMap);
-SAMPLER2D(sampler_UnlitColorMap);
+SAMPLER(sampler_UnlitColorMap);
-SAMPLER2D(sampler_DistortionVectorMap);
+SAMPLER(sampler_DistortionVectorMap);
-SAMPLER2D(sampler_EmissiveColorMap);
+SAMPLER(sampler_EmissiveColorMap);
 float4 _EmissiveColorMap_ST;
 
 float _EmissiveIntensity;

ScriptableRenderPipeline/HDRenderPipeline/RenderPipelineResources/DepthDownsample.compute

-#include "ShaderLibrary/Common.hlsl"
-
-Texture2D<float> _Source;
-RWTexture2D<float> _Result;
-
-SamplerState sampler_LinearClamp;
-
-CBUFFER_START(cb)
-    float4 _Size;
-CBUFFER_END
-
-#pragma kernel KMain
-[numthreads(8, 8, 1)]
-void KMain(uint2 groupId : SV_GroupID, uint2 groupThreadId : SV_GroupThreadID, uint2 dispatchThreadId : SV_DispatchThreadID)
-{
-    // Upper-left pixel coordinate of quad that this thread will read
-    int2 threadUL = dispatchThreadId;
-
-    // Downsample the block
-    float2 offset = float2(threadUL);
-    float p00 = _Source.SampleLevel(sampler_LinearClamp, (offset                   ) * _Size.zw, 0.0).x;
-    float p10 = _Source.SampleLevel(sampler_LinearClamp, (offset + float2(1.0, 0.0)) * _Size.zw, 0.0).x;
-    float p01 = _Source.SampleLevel(sampler_LinearClamp, (offset + float2(0.0, 1.0)) * _Size.zw, 0.0).x;
-    float p11 = _Source.SampleLevel(sampler_LinearClamp, (offset + float2(1.0, 1.0)) * _Size.zw, 0.0).x;
-
-    float depth = min(min(min(p00, p01), p10), p11);
-
-    // Write to the final target
-    _Result[dispatchThreadId] = depth;
+#include "ShaderLibrary/Common.hlsl"
+
+Texture2D<float> _Source;
+RWTexture2D<float> _Result;
+
+SamplerState sampler_PointClamp;    //TODO: could we use min-sampler instead of using ALU?
+
+CBUFFER_START(cb)
+float4 _SrcSize;
+CBUFFER_END
+
+#pragma kernel KMain
+[numthreads(8, 8, 1)]
+void KMain(uint2 groupId : SV_GroupID, uint2 groupThreadId : SV_GroupThreadID, uint2 dispatchThreadId : SV_DispatchThreadID)
+{
+    // Upper-left pixel coordinate of quad that this thread will read
+    int2 threadUL = dispatchThreadId;
+
+    // Downsample the block
+    float2 offset = float2(threadUL) * 2.0f + 1.0f;
+    float4 depths = _Source.GatherRed(sampler_PointClamp, offset * _SrcSize.zw, 0.0);
+
+    float minDepth = min(min(depths.x, depths.y), min(depths.z, depths.w));
+
+    // Write to the final target
+    _Result[dispatchThreadId] = minDepth;
 }

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
 
 // ----------------------------------------------------------------------------
 
-TEXTURE2D_FLOAT(_MainDepthTexture);
-SAMPLER2D(sampler_MainDepthTexture);
+// These are the samplers available in the HDRenderPipeline.
+// Avoid declaring extra samplers as they are 4x SGPR each on GCN.
+SAMPLER(s_linear_clamp_sampler);
+SAMPLER(s_trilinear_clamp_sampler);
+
+// ----------------------------------------------------------------------------
+
+TEXTURE2D(_MainDepthTexture);
+SAMPLER(sampler_MainDepthTexture);
-SAMPLER2D(samplerunity_Lightmap);
+SAMPLER(samplerunity_Lightmap);
-SAMPLER2D(samplerunity_DynamicLightmap);
+SAMPLER(samplerunity_DynamicLightmap);
 
 TEXTURE2D(unity_DynamicDirectionality);
 
 // TODO: Change code here so probe volume use only one transform instead of all this parameters!
-TEXTURE3D_FLOAT(unity_ProbeVolumeSH);
-SAMPLER3D(samplerunity_ProbeVolumeSH);
+TEXTURE3D(unity_ProbeVolumeSH);
+SAMPLER(samplerunity_ProbeVolumeSH);
+	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/BlitCubemap.shader

             #include "ShaderLibrary/Common.hlsl"
 
             TEXTURECUBE(_MainTex);
-            SAMPLERCUBE(sampler_MainTex);
+            SAMPLER(sampler_MainTex);
             float _faceIndex;
 
             struct appdata_t {

ScriptableRenderPipeline/HDRenderPipeline/Sky/HDRISky/Resources/SkyHDRI.shader

     #include "ShaderLibrary/CommonLighting.hlsl"
 
     TEXTURECUBE(_Cubemap);
-    SAMPLERCUBE(sampler_Cubemap);
+    SAMPLER(sampler_Cubemap);
 
     float4   _SkyParam; // x exposure, y multiplier, z rotation
     float4x4 _PixelCoordToViewDirWS; // Actually just 3x3, but Unity can only set 4x4

ScriptableRenderPipeline/HDRenderPipeline/Sky/SkyManager.cs

-using UnityEngine.Rendering;
+using UnityEngine.Rendering;
 using System;
 
 namespace UnityEngine.Experimental.Rendering.HDPipeline
                 else
                     return m_VisualSky.reflectionTexture;
             }
-        }
-        
+                }
+
-        {
+                {
-            {
+        {
-                    {
+            {
-                    }
+            }
-                    {
+            {
-                    }
+        }
 
             m_VisualSky.skySettings = newSkySettings;
             m_BakingSky.skySettings = SkySettings.GetBakingSkySettings();
             m_LastFrameUpdated = -1;
         }
 
-        public void Build(RenderPipelineResources renderPipelinesResources, IBLFilterGGX iblFilterGGX)
+        public void Build(RenderPipelineResources renderPipelineResources, IBLFilterGGX iblFilterGGX)
         {
             // For now, both these rendering context will allocate render textures
             // In theory, when we have a lighting override we don't need any cubemaps from the visual sky so we could avoid allocating them
             m_BakingSky = new SkyRenderingContext(false, iblFilterGGX);
 
-            m_StandardSkyboxMaterial = CoreUtils.CreateEngineMaterial(renderPipelinesResources.skyboxCubemap);
-            m_BlitCubemapMaterial = CoreUtils.CreateEngineMaterial(renderPipelinesResources.blitCubemap);
-            m_OpaqueAtmScatteringMaterial = CoreUtils.CreateEngineMaterial(renderPipelinesResources.opaqueAtmosphericScattering);
+            m_StandardSkyboxMaterial = CoreUtils.CreateEngineMaterial(renderPipelineResources.skyboxCubemap);
+
+            m_BlitCubemapMaterial = CoreUtils.CreateEngineMaterial(renderPipelineResources.blitCubemap);
+
+            m_OpaqueAtmScatteringMaterial = CoreUtils.CreateEngineMaterial(renderPipelineResources.opaqueAtmosphericScattering);
+
+            m_CurrentUpdateTime = 0.0f;
         }
 
         public void Cleanup()
         public bool IsSkyValid()
         {
             return m_VisualSky.IsValid();
-        }
+            }
 
 
         void BlitCubemap(CommandBuffer cmd, Cubemap source, RenderTexture dest)
                 // Here we update the global SkyMaterial so that it uses our baking sky cubemap. This way, next time the GI is baked, the right sky will be present.
                 float intensity = m_BakingSky.IsValid() ? 1.0f : 0.0f; // Eliminate all diffuse if we don't have a skybox (meaning for now the background is black in HDRP)
                 m_StandardSkyboxMaterial.SetTexture("_Tex", m_BakingSky.cubemapRT);
-                RenderSettings.skybox = m_StandardSkyboxMaterial; // Setup this material as the default to be use in RenderSettings
-                RenderSettings.ambientIntensity = intensity;
-                RenderSettings.ambientMode = AmbientMode.Skybox; // Force skybox for our HDRI
-                RenderSettings.reflectionIntensity = intensity;
-                RenderSettings.customReflection = null;
+                    RenderSettings.skybox = m_StandardSkyboxMaterial; // Setup this material as the default to be use in RenderSettings
+                    RenderSettings.ambientIntensity = intensity;
+                    RenderSettings.ambientMode = AmbientMode.Skybox; // Force skybox for our HDRI
+                    RenderSettings.reflectionIntensity = intensity;
+                    RenderSettings.customReflection = null;
-                DynamicGI.UpdateEnvironment();
+                    DynamicGI.UpdateEnvironment();
 
                 m_NeedUpdateBakingSky = false;
             }
 
             m_NeedUpdateBakingSky = m_BakingSky.UpdateEnvironment(camera, sunLight, m_UpdateRequired, cmd);
             if(m_LightingOverrideSky.IsValid())
-            {
+                {
-            {
+                    {
-            }
+                        }
 
             m_UpdateRequired = false;
 
             if (IsSkyValid())
             {
                 cmd.SetGlobalInt(HDShaderIDs._EnvLightSkyEnabled, 1);
-            }
+                    }
+                }
-        }
-        }
+            }
-                CoreUtils.DrawFullScreen(cmd, m_OpaqueAtmScatteringMaterial);
+                    CoreUtils.DrawFullScreen(cmd, m_OpaqueAtmScatteringMaterial);
+                }
-        }
 
         public Texture2D ExportSkyToTexture()
         {

ScriptableRenderPipeline/HDRenderPipeline/Sky/SkyVariables.hlsl

 #define UNITY_SKY_VARIABLES_INCLUDED
 
 TEXTURECUBE(_SkyTexture);
-SAMPLERCUBE(sampler_SkyTexture); // NOTE: Sampler could be share here with _EnvTextures. Don't know if the shader compiler will complain...
 
 CBUFFER_START(SkyParameters)
 float _SkyTextureMipCount;
 {
-    return SAMPLE_TEXTURECUBE(_SkyTexture, sampler_SkyTexture, texCoord);
+    return SAMPLE_TEXTURECUBE(_SkyTexture, s_trilinear_clamp_sampler, texCoord);
-    return SAMPLE_TEXTURECUBE_LOD(_SkyTexture, sampler_SkyTexture, texCoord, lod);
+    return SAMPLE_TEXTURECUBE_LOD(_SkyTexture, s_trilinear_clamp_sampler, texCoord, lod);
 }
 
 #endif

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;
             "RenderPipeline"
         };
 
-        private static readonly string[] s_PipelinePath =
-        {
-            "LightweightPipeline",
-            "HDRenderPipeline",
-        };
-
         // info that gets generated for use
         // in a dod way
         public struct TestInfo
 
         }
 
-		// 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 scenes
+            public static IEnumerable HDRP
+            {
+                get
+                {
+                    return GetScenesForPipelineID("HDRP");
+                }
+            }
+
+            public static IEnumerable LWRP
-                    var absoluteScenesPath = s_Path.Aggregate(s_RootPath, Path.Combine);
+                    return GetScenesForPipelineID("LWRP");
+                }
+            }
+
+            public static  IEnumerable GetScenesForPipelineID( string _pipelineID )
+            {
+                return GetScenesForPipeline( renderPipelineScenesFolder[_pipelineID] );
+            }
+
+            public static IEnumerable GetScenesForPipeline(string _pipelinePath)
+            {
+                var absoluteScenesPath = s_Path.Aggregate(s_RootPath, Path.Combine);
-                    foreach (var pipelinePath in s_PipelinePath)
-                    {
+                var filesPath = Path.Combine(absoluteScenesPath, _pipelinePath);
-                        var filesPath = Path.Combine(absoluteScenesPath, pipelinePath);
+                // find all the scenes
+                var allPaths = Directory.GetFiles(filesPath, "*.unity", SearchOption.AllDirectories);
-                        // find all the scenes
-                        var allPaths = System.IO.Directory.GetFiles(filesPath, "*.unity", System.IO.SearchOption.AllDirectories);
+                // Convert to List for easy sorting in alphabetical ordre
+                List<string> allPaths_List = new List<string>(allPaths);
+                allPaths_List.Sort();
-                        // construct all the needed test infos
-                        foreach (var path in allPaths)
-                        {
-                            var p = new FileInfo(path);
-                            var split = s_Path.Aggregate("", Path.Combine);
-                            split = string.Format("{0}{1}", split, Path.DirectorySeparatorChar);
-                            var splitPaths = p.FullName.Split(new[] { split }, StringSplitOptions.RemoveEmptyEntries);
+                // construct all the needed test infos
+                for (int i=0; i<allPaths_List.Count; ++i)
+                {
+                    var path = allPaths_List[i];
-                            yield return new TestInfo
-                            {
-                                name = p.Name,
-                                relativePath = splitPaths.Last(),
-                                threshold = 0.02f,
-                                frameWait = 100
-                            };
-                        }
-                    }
+                    var p = new FileInfo(path);
+                    var split = s_Path.Aggregate("", Path.Combine);
+                    split = string.Format("{0}{1}", split, Path.DirectorySeparatorChar);
+                    var splitPaths = p.FullName.Split(new[] { split }, StringSplitOptions.RemoveEmptyEntries);
+
+                    yield return new TestInfo
+                    {
+                        name = p.Name,
+                        relativePath = splitPaths.Last(),
+                        threshold = 0.02f,
+                        frameWait = 100
+                    };
-        [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()
+        {
+            SetupRenderPipeAsset();
+        }
+
+        [OneTimeTearDown]
+        public void OnTimeTearDown()
+        {
+            RestoreRenderPipeAsset();
+        }
+
+        public static RenderPipelineAsset GetRenderPipelineAsset(string _SRP_ID)
+        {
+            string absolutePath = s_Path.Aggregate(s_RootPath, Path.Combine);
+
+            string filePath = Path.Combine(absolutePath, renderPipelineAssets[_SRP_ID] );
+
+            return (RenderPipelineAsset)AssetDatabase.LoadAssetAtPath(filePath, typeof(RenderPipelineAsset));
+        }
+
+        public static RenderPipelineAsset beforeTestsRenderPipeAsset;
+        public static RenderPipelineAsset wantedTestsRenderPipeAsset;
+
+        public void SetupRenderPipeAsset()
-            var testSetup = Object.FindObjectOfType<SetupSceneForRenderPipelineTest>();
-            if (testSetup == null)
-                return;
+            Debug.Log("Set " + _SRP_ID + " render pipeline.");
+
+            beforeTestsRenderPipeAsset = UnityEngine.Rendering.GraphicsSettings.renderPipelineAsset;
+            wantedTestsRenderPipeAsset = GetRenderPipelineAsset(_SRP_ID);
+
+            if (wantedTestsRenderPipeAsset != beforeTestsRenderPipeAsset)
+                UnityEngine.Rendering.GraphicsSettings.renderPipelineAsset = wantedTestsRenderPipeAsset;
+        }
-            testSetup.TearDown();
+        public void RestoreRenderPipeAsset()
+        {
+            if (wantedTestsRenderPipeAsset != beforeTestsRenderPipeAsset)
+                UnityEngine.Rendering.GraphicsSettings.renderPipelineAsset = beforeTestsRenderPipeAsset;
-        [UnityTest]
-        public IEnumerator TestScene([ValueSource(typeof(CollectScenes), "scenes")]TestInfo testInfo)
+
+        // 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/LICENSE

+Unity Companion License (“License”)
+Software Copyright © 2017 Unity Technologies ApS 
+
+Unity Technologies ApS (“Unity”) grants to you a worldwide, non-exclusive,
+no-charge, and royalty-free copyright license to reproduce, prepare derivative
+works of, publicly display, publicly perform, sublicense, and distribute the
+software that is made available under this License (“Software”), subject to the
+following terms and conditions: 
+
+1. Unity Companion Use Only. Exercise of the license granted herein is limited
+to exercise for the creation, use, and/or distribution of applications,
+software, or other content pursuant to a valid Unity content authoring and
+rendering engine software license (“Engine License”). That means while use of
+the Software is not limited to use in the software licensed under the Engine
+License, the Software may not be used for any purpose other than the creation,
+use, and/or distribution of Engine License-dependent applications, software, or
+other content. No other exercise of the license granted herein is permitted,
+and in no event may the Software be used for competitive analysis or to develop
+a competing product or service.
+
+2. No Modification of Engine License. Neither this License nor any exercise of
+the license granted herein modifies the Engine License in any way.
+
+3. Ownership & Grant Back to You. 
+
+3.1 You own your content. In this License, “derivative works” means derivatives
+of the Software itself--works derived only from the Software by you under this
+License (for example, modifying the code of the Software itself to improve its
+efficacy); “derivative works” of the Software do not include, for example,
+games, apps, or content that you create using the Software. You keep all right,
+title, and interest to your own content.
+
+3.2 Unity owns its content. While you keep all right, title, and interest to
+your own content per the above, as between Unity and you, Unity will own all
+right, title, and interest to all intellectual property rights (including
+patent, trademark, and copyright) in the Software and derivative works of the
+Software, and you hereby assign and agree to assign all such rights in those
+derivative works to Unity. 
+
+3.3 You have a license to those derivative works. Subject to this License,
+Unity grants to you the same worldwide, non-exclusive, no-charge, and
+royalty-free copyright license to derivative works of the Software you create
+as is granted to you for the Software under this License.
+
+4. Trademarks. You are not granted any right or license under this License to
+use any trademarks, service marks, trade names, products names, or branding of
+Unity or its affiliates (“Trademarks”). Descriptive uses of Trademarks are
+permitted; see, for example, Unity’s Branding Usage Guidelines at
+https://unity3d.com/public-relations/brand.
+
+5. Notices & Third-Party Rights. This License, including the copyright notice
+associated with the Software, must be provided in all substantial portions of
+the Software and derivative works thereof (or, if that is impracticable, in any
+other location where such notices are customarily placed). Further, if the
+Software is accompanied by a Unity “third-party notices” or similar file, you
+acknowledge and agree that software identified in that file is governed by
+those separate license terms.
+
+6. DISCLAIMER, LIMITATION OF LIABILITY. THE SOFTWARE AND ANY DERIVATIVE WORKS
+THEREOF IS PROVIDED ON AN "AS IS" BASIS, AND IS PROVIDED WITHOUT WARRANTY OF
+ANY KIND, WHETHER EXPRESS OR IMPLIED, INCLUDING ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND/OR NONINFRINGEMENT. IN
+NO EVENT SHALL ANY COPYRIGHT HOLDER OR AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES
+(WHETHER DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL,
+INCLUDING PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, LOSS OF USE, DATA, OR
+PROFITS, AND BUSINESS INTERRUPTION), OR OTHER LIABILITY WHATSOEVER, WHETHER IN
+AN ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING FROM OR OUT OF, OR IN
+CONNECTION WITH, THE SOFTWARE OR ANY DERIVATIVE WORKS THEREOF OR THE USE OF OR
+OTHER DEALINGS IN SAME, EVEN WHERE ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+7. USE IS ACCEPTANCE and License Versions. Your receipt and use of the Software
+constitutes your acceptance of this License and its terms and conditions.
+Software released by Unity under this License may be modified or updated and
+the License with it; upon any such modification or update, you will comply with
+the terms of the updated License for any use of any of the Software under the
+updated License. 
+
+8. Use in Compliance with Law and Termination. Your exercise of the license
+granted herein will at all times be in compliance with applicable law and will
+not infringe any proprietary rights (including intellectual property rights);
+this License will terminate immediately on any breach by you of this License.
+
+9. Severability. If any provision of this License is held to be unenforceable
+or invalid, that provision will be enforced to the maximum extent possible and
+the other provisions will remain in full force and effect.
+
+10. Governing Law and Venue. This License is governed by and construed in
+accordance with the laws of Denmark, except for its conflict of laws rules; the
+United Nations Convention on Contracts for the International Sale of Goods will
+not apply. If you reside (or your principal place of business is) within the
+United States, you and Unity agree to submit to the personal and exclusive
+jurisdiction of and venue in the state and federal courts located in San
+Francisco County, California concerning any dispute arising out of this License
+(“Dispute”). If you reside (or your principal place of business is) outside the
+United States, you and Unity agree to submit to the personal and exclusive
+jurisdiction of and venue in the courts located in Copenhagen, Denmark
+concerning any Dispute. 

ScriptableRenderPipeline/Core/LICENSE.meta

+fileFormatVersion: 2
+guid: ef45a081b89729f48887261245188e37
+DefaultImporter:
+  externalObjects: {}
+  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/LICENSE

+Unity Companion License (“License”)
+Software Copyright © 2017 Unity Technologies ApS 
+
+Unity Technologies ApS (“Unity”) grants to you a worldwide, non-exclusive,
+no-charge, and royalty-free copyright license to reproduce, prepare derivative
+works of, publicly display, publicly perform, sublicense, and distribute the
+software that is made available under this License (“Software”), subject to the
+following terms and conditions: 
+
+1. Unity Companion Use Only. Exercise of the license granted herein is limited
+to exercise for the creation, use, and/or distribution of applications,
+software, or other content pursuant to a valid Unity content authoring and
+rendering engine software license (“Engine License”). That means while use of
+the Software is not limited to use in the software licensed under the Engine
+License, the Software may not be used for any purpose other than the creation,
+use, and/or distribution of Engine License-dependent applications, software, or
+other content. No other exercise of the license granted herein is permitted,
+and in no event may the Software be used for competitive analysis or to develop
+a competing product or service.
+
+2. No Modification of Engine License. Neither this License nor any exercise of
+the license granted herein modifies the Engine License in any way.
+
+3. Ownership & Grant Back to You. 
+
+3.1 You own your content. In this License, “derivative works” means derivatives
+of the Software itself--works derived only from the Software by you under this
+License (for example, modifying the code of the Software itself to improve its
+efficacy); “derivative works” of the Software do not include, for example,
+games, apps, or content that you create using the Software. You keep all right,
+title, and interest to your own content.
+
+3.2 Unity owns its content. While you keep all right, title, and interest to
+your own content per the above, as between Unity and you, Unity will own all
+right, title, and interest to all intellectual property rights (including
+patent, trademark, and copyright) in the Software and derivative works of the
+Software, and you hereby assign and agree to assign all such rights in those
+derivative works to Unity. 
+
+3.3 You have a license to those derivative works. Subject to this License,
+Unity grants to you the same worldwide, non-exclusive, no-charge, and
+royalty-free copyright license to derivative works of the Software you create
+as is granted to you for the Software under this License.
+
+4. Trademarks. You are not granted any right or license under this License to
+use any trademarks, service marks, trade names, products names, or branding of
+Unity or its affiliates (“Trademarks”). Descriptive uses of Trademarks are
+permitted; see, for example, Unity’s Branding Usage Guidelines at
+https://unity3d.com/public-relations/brand.
+
+5. Notices & Third-Party Rights. This License, including the copyright notice
+associated with the Software, must be provided in all substantial portions of
+the Software and derivative works thereof (or, if that is impracticable, in any
+other location where such notices are customarily placed). Further, if the
+Software is accompanied by a Unity “third-party notices” or similar file, you
+acknowledge and agree that software identified in that file is governed by
+those separate license terms.
+
+6. DISCLAIMER, LIMITATION OF LIABILITY. THE SOFTWARE AND ANY DERIVATIVE WORKS
+THEREOF IS PROVIDED ON AN "AS IS" BASIS, AND IS PROVIDED WITHOUT WARRANTY OF
+ANY KIND, WHETHER EXPRESS OR IMPLIED, INCLUDING ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND/OR NONINFRINGEMENT. IN
+NO EVENT SHALL ANY COPYRIGHT HOLDER OR AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES
+(WHETHER DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL,
+INCLUDING PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, LOSS OF USE, DATA, OR
+PROFITS, AND BUSINESS INTERRUPTION), OR OTHER LIABILITY WHATSOEVER, WHETHER IN
+AN ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING FROM OR OUT OF, OR IN
+CONNECTION WITH, THE SOFTWARE OR ANY DERIVATIVE WORKS THEREOF OR THE USE OF OR
+OTHER DEALINGS IN SAME, EVEN WHERE ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+7. USE IS ACCEPTANCE and License Versions. Your receipt and use of the Software
+constitutes your acceptance of this License and its terms and conditions.
+Software released by Unity under this License may be modified or updated and
+the License with it; upon any such modification or update, you will comply with
+the terms of the updated License for any use of any of the Software under the
+updated License. 
+
+8. Use in Compliance with Law and Termination. Your exercise of the license
+granted herein will at all times be in compliance with applicable law and will
+not infringe any proprietary rights (including intellectual property rights);
+this License will terminate immediately on any breach by you of this License.
+
+9. Severability. If any provision of this License is held to be unenforceable
+or invalid, that provision will be enforced to the maximum extent possible and
+the other provisions will remain in full force and effect.
+
+10. Governing Law and Venue. This License is governed by and construed in
+accordance with the laws of Denmark, except for its conflict of laws rules; the
+United Nations Convention on Contracts for the International Sale of Goods will
+not apply. If you reside (or your principal place of business is) within the
+United States, you and Unity agree to submit to the personal and exclusive
+jurisdiction of and venue in the state and federal courts located in San
+Francisco County, California concerning any dispute arising out of this License
+(“Dispute”). If you reside (or your principal place of business is) outside the
+United States, you and Unity agree to submit to the personal and exclusive
+jurisdiction of and venue in the courts located in Copenhagen, Denmark
+concerning any Dispute. 

ScriptableRenderPipeline/HDRenderPipeline/LICENSE.meta

+fileFormatVersion: 2
+guid: 31351b1043fde6342afe25329f2e52f7
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

ScriptableRenderPipeline/HDRenderPipeline/RenderPipelineResources/CopyStencilBuffer.shader.meta

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

ScriptableRenderPipeline/LightweightPipeline/LICENSE

+Unity Companion License (“License”)
+Software Copyright © 2017 Unity Technologies ApS 
+
+Unity Technologies ApS (“Unity”) grants to you a worldwide, non-exclusive,
+no-charge, and royalty-free copyright license to reproduce, prepare derivative
+works of, publicly display, publicly perform, sublicense, and distribute the
+software that is made available under this License (“Software”), subject to the
+following terms and conditions: 
+
+1. Unity Companion Use Only. Exercise of the license granted herein is limited
+to exercise for the creation, use, and/or distribution of applications,
+software, or other content pursuant to a valid Unity content authoring and
+rendering engine software license (“Engine License”). That means while use of
+the Software is not limited to use in the software licensed under the Engine
+License, the Software may not be used for any purpose other than the creation,
+use, and/or distribution of Engine License-dependent applications, software, or
+other content. No other exercise of the license granted herein is permitted,
+and in no event may the Software be used for competitive analysis or to develop
+a competing product or service.
+
+2. No Modification of Engine License. Neither this License nor any exercise of
+the license granted herein modifies the Engine License in any way.
+
+3. Ownership & Grant Back to You. 
+
+3.1 You own your content. In this License, “derivative works” means derivatives
+of the Software itself--works derived only from the Software by you under this
+License (for example, modifying the code of the Software itself to improve its
+efficacy); “derivative works” of the Software do not include, for example,
+games, apps, or content that you create using the Software. You keep all right,
+title, and interest to your own content.
+
+3.2 Unity owns its content. While you keep all right, title, and interest to
+your own content per the above, as between Unity and you, Unity will own all
+right, title, and interest to all intellectual property rights (including
+patent, trademark, and copyright) in the Software and derivative works of the
+Software, and you hereby assign and agree to assign all such rights in those
+derivative works to Unity. 
+
+3.3 You have a license to those derivative works. Subject to this License,
+Unity grants to you the same worldwide, non-exclusive, no-charge, and
+royalty-free copyright license to derivative works of the Software you create
+as is granted to you for the Software under this License.
+
+4. Trademarks. You are not granted any right or license under this License to
+use any trademarks, service marks, trade names, products names, or branding of
+Unity or its affiliates (“Trademarks”). Descriptive uses of Trademarks are
+permitted; see, for example, Unity’s Branding Usage Guidelines at
+https://unity3d.com/public-relations/brand.
+
+5. Notices & Third-Party Rights. This License, including the copyright notice
+associated with the Software, must be provided in all substantial portions of
+the Software and derivative works thereof (or, if that is impracticable, in any
+other location where such notices are customarily placed). Further, if the
+Software is accompanied by a Unity “third-party notices” or similar file, you
+acknowledge and agree that software identified in that file is governed by
+those separate license terms.
+
+6. DISCLAIMER, LIMITATION OF LIABILITY. THE SOFTWARE AND ANY DERIVATIVE WORKS
+THEREOF IS PROVIDED ON AN "AS IS" BASIS, AND IS PROVIDED WITHOUT WARRANTY OF
+ANY KIND, WHETHER EXPRESS OR IMPLIED, INCLUDING ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND/OR NONINFRINGEMENT. IN
+NO EVENT SHALL ANY COPYRIGHT HOLDER OR AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES
+(WHETHER DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL,
+INCLUDING PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, LOSS OF USE, DATA, OR
+PROFITS, AND BUSINESS INTERRUPTION), OR OTHER LIABILITY WHATSOEVER, WHETHER IN
+AN ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING FROM OR OUT OF, OR IN
+CONNECTION WITH, THE SOFTWARE OR ANY DERIVATIVE WORKS THEREOF OR THE USE OF OR
+OTHER DEALINGS IN SAME, EVEN WHERE ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+7. USE IS ACCEPTANCE and License Versions. Your receipt and use of the Software
+constitutes your acceptance of this License and its terms and conditions.
+Software released by Unity under this License may be modified or updated and
+the License with it; upon any such modification or update, you will comply with
+the terms of the updated License for any use of any of the Software under the
+updated License. 
+
+8. Use in Compliance with Law and Termination. Your exercise of the license
+granted herein will at all times be in compliance with applicable law and will
+not infringe any proprietary rights (including intellectual property rights);
+this License will terminate immediately on any breach by you of this License.
+
+9. Severability. If any provision of this License is held to be unenforceable
+or invalid, that provision will be enforced to the maximum extent possible and
+the other provisions will remain in full force and effect.
+
+10. Governing Law and Venue. This License is governed by and construed in
+accordance with the laws of Denmark, except for its conflict of laws rules; the
+United Nations Convention on Contracts for the International Sale of Goods will
+not apply. If you reside (or your principal place of business is) within the
+United States, you and Unity agree to submit to the personal and exclusive
+jurisdiction of and venue in the state and federal courts located in San
+Francisco County, California concerning any dispute arising out of this License
+(“Dispute”). If you reside (or your principal place of business is) outside the
+United States, you and Unity agree to submit to the personal and exclusive
+jurisdiction of and venue in the courts located in Copenhagen, Denmark
+concerning any Dispute.