merged master

Assets/GraphicsTests/RenderPipeline/HDRenderPipeline/HDRPAsset/HDRenderPipelineResourcesTest.asset

     type: 3}
   buildMaterialFlagsShader: {fileID: 7200000, guid: fb3eda953cd6e634e877fb777be2cd08,
     type: 3}
-  shadeOpaqueShader: {fileID: 7200000, guid: 0b64f79746d2daf4198eaf6eab9af259, type: 3}
+  deferredComputeShader: {fileID: 7200000, guid: 0b64f79746d2daf4198eaf6eab9af259,
+    type: 3}
+  cameraMotionVectors: {fileID: 4800000, guid: 035941b63024d1943af48811c1db20d9, type: 3}
   blitCubemap: {fileID: 4800000, guid: d05913e251bed7a4992c921c62e1b647, type: 3}
   buildProbabilityTables: {fileID: 7200000, guid: b9f26cf340afe9145a699753531b2a4c,
     type: 3}

Assets/ScriptableRenderPipeline/BasicRenderPipeline/BasicRenderPipeline.cs

 using UnityEngine;
 using UnityEngine.Rendering;
 using UnityEngine.Experimental.Rendering;
+using UnityEngine.XR;
 
 // Very basic scriptable rendering loop example:
 // - Use with BasicRenderPipelineShader.shader (the loop expects "BasicPass" pass type to exist)
 [ExecuteInEditMode]
 public class BasicRenderPipeline : RenderPipelineAsset
 {
+    public bool UseIntermediateRenderTargetBlit;
+
 #if UNITY_EDITOR
     [UnityEditor.MenuItem("RenderPipeline/Create BasicRenderPipeline")]
     static void CreateBasicRenderPipeline()
 
     protected override IRenderPipeline InternalCreatePipeline()
     {
-        return new BasicRenderPipelineInstance();
+        return new BasicRenderPipelineInstance(UseIntermediateRenderTargetBlit);
+    bool useIntermediateBlit;
+
+    public BasicRenderPipelineInstance()
+    {
+        useIntermediateBlit = false;
+    }
+
+    public BasicRenderPipelineInstance(bool useIntermediate)
+    {
+        useIntermediateBlit = useIntermediate;
+    }
+
-        BasicRendering.Render(renderContext, cameras);
+        BasicRendering.Render(renderContext, cameras, useIntermediateBlit);
     }
 }
 
 
-    public static void Render(ScriptableRenderContext context, IEnumerable<Camera> cameras)
+    static void ConfigureAndBindIntermediateRenderTarget(ScriptableRenderContext context, Camera cam, bool stereoEnabled, out RenderTargetIdentifier intermediateRTID, out bool isRTTexArray)
+        var intermediateRT = Shader.PropertyToID("_IntermediateTarget");
+        intermediateRTID = new RenderTargetIdentifier(intermediateRT);
+
+        isRTTexArray = false;
+
+        var bindIntermediateRTCmd = CommandBufferPool.Get("Bind intermediate RT");
+
+        if (stereoEnabled)
+        {
+            RenderTextureDescriptor vrDesc = XRSettings.eyeTextureDesc;
+            vrDesc.depthBufferBits = 24;
+
+            if (vrDesc.dimension == TextureDimension.Tex2DArray)
+                isRTTexArray = true;
+
+            bindIntermediateRTCmd.GetTemporaryRT(intermediateRT, vrDesc, FilterMode.Point);
+        }
+        else
+        {
+            int w = cam.pixelWidth;
+            int h = cam.pixelHeight;
+            bindIntermediateRTCmd.GetTemporaryRT(intermediateRT, w, h, 24, FilterMode.Point, RenderTextureFormat.Default, RenderTextureReadWrite.Default, 1, true);
+        }
+
+        if (isRTTexArray)
+            bindIntermediateRTCmd.SetRenderTarget(intermediateRTID, 0, CubemapFace.Unknown, -1); // depthSlice == -1 => bind all slices
+        else
+            bindIntermediateRTCmd.SetRenderTarget(intermediateRTID);
+
+        context.ExecuteCommandBuffer(bindIntermediateRTCmd);
+        CommandBufferPool.Release(bindIntermediateRTCmd);
+    }
+
+    static void BlitFromIntermediateToCameraTarget(ScriptableRenderContext context, RenderTargetIdentifier intermediateRTID, bool isRTTexArray)
+    {
+        var blitIntermediateRTCmd = CommandBufferPool.Get("Copy intermediate RT to default RT");
+
+        if (isRTTexArray)
+        {
+            // Currently, Blit does not allow specification of a slice in a texture array.
+            // It can use the CurrentActive render texture's bound slices, so we use that
+            // as a temporary workaround.
+            blitIntermediateRTCmd.SetRenderTarget(BuiltinRenderTextureType.CameraTarget, 0, CubemapFace.Unknown, -1);
+            blitIntermediateRTCmd.Blit(intermediateRTID, BuiltinRenderTextureType.CurrentActive);
+        }
+        else
+            blitIntermediateRTCmd.Blit(intermediateRTID, BuiltinRenderTextureType.CameraTarget);
+
+        context.ExecuteCommandBuffer(blitIntermediateRTCmd);
+        CommandBufferPool.Release(blitIntermediateRTCmd);
+
+    }
+
+    public static void Render(ScriptableRenderContext context, IEnumerable<Camera> cameras, bool useIntermediateBlitPath)
+    {
+        bool stereoEnabled = XRSettings.isDeviceActive;
+
-            if (!CullResults.GetCullingParameters(camera, out cullingParams))
+            // Stereo-aware culling parameters are configured to perform a single cull for both eyes
+            if (!CullResults.GetCullingParameters(camera, stereoEnabled, out cullingParams))
                 continue;
             CullResults cull = new CullResults();
             CullResults.Cull(ref cullingParams, context, ref cull);
-            context.SetupCameraProperties(camera);
+            // If stereo is enabled, we also configure stereo matrices, viewports, and XR device render targets
+            context.SetupCameraProperties(camera, stereoEnabled);
+
+            // Draws in-between [Start|Stop]MultiEye are stereo-ized by engine
+            if (stereoEnabled)
+                context.StartMultiEye(camera);
+
+            RenderTargetIdentifier intermediateRTID = new RenderTargetIdentifier(BuiltinRenderTextureType.CurrentActive);
+            bool isIntermediateRTTexArray = false;
+            if (useIntermediateBlitPath)
+            {
+                ConfigureAndBindIntermediateRenderTarget(context, camera, stereoEnabled, out intermediateRTID, out isIntermediateRTTexArray);
+            }
 
             // clear depth buffer
             var cmd = CommandBufferPool.Get();
             settings.sorting.flags = SortFlags.CommonTransparent;
             settings.inputFilter.SetQueuesTransparent();
             context.DrawRenderers(ref settings);
+
+            if (useIntermediateBlitPath)
+            {
+                BlitFromIntermediateToCameraTarget(context, intermediateRTID, isIntermediateRTTexArray);
+            }
+
+            if (stereoEnabled)
+            {
+                context.StopMultiEye(camera);
+                // StereoEndRender will reset state on the camera to pre-Stereo settings,
+                // and invoke XR based events/callbacks.
+                context.StereoEndRender(camera);
+            }
 
             context.Submit();
         }

Assets/ScriptableRenderPipeline/BasicRenderPipeline/BasicRenderPipelineShader.shader

 #pragma target 3.0
 #pragma vertex vert
 #pragma fragment frag
+#pragma multi_compile _ UNITY_SINGLE_PASS_STEREO STEREO_INSTANCING_ON STEREO_MULTIVIEW_ON
 #pragma shader_feature _METALLICGLOSSMAP
 #include "UnityCG.cginc"
 #include "UnityStandardBRDF.cginc"
     float3 positionWS : TEXCOORD1;
     float3 normalWS : TEXCOORD2;
     float4 hpos : SV_POSITION;
+    UNITY_VERTEX_OUTPUT_STEREO
 };
 
 float4 _MainTex_ST;
     v2f o;
+    UNITY_SETUP_INSTANCE_ID(v);
+    UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
     o.uv = TRANSFORM_TEX(v.texcoord,_MainTex);
     o.hpos = UnityObjectToClipPos(v.vertex);
     o.positionWS = mul(unity_ObjectToWorld, v.vertex).xyz;

Assets/ScriptableRenderPipeline/Core/Shadow/AdditionalShadowData.cs

         [HideInInspector, SerializeField]
         private float[] shadowCascadeRatios = new float[3] { 0.05f, 0.2f, 0.3f };
         [HideInInspector, SerializeField]
+        private float[] shadowCascadeBorders = new float[4] { 0.2f, 0.2f, 0.2f, 0.2f };
+        [HideInInspector, SerializeField]
         private int shadowAlgorithm;
         [HideInInspector, SerializeField]
         private int shadowVariant;
         private ShadowData[] shadowDatas = new ShadowData[0];
 
         public int cascadeCount { get { return shadowCascadeCount; } }
-        public void GetShadowCascades(out int cascadeCount, out float[] cascadeRatios) { cascadeCount = shadowCascadeCount; cascadeRatios = shadowCascadeRatios; }
+        public void GetShadowCascades(out int cascadeCount, out float[] cascadeRatios, out float[] cascadeBorders) { cascadeCount = shadowCascadeCount; cascadeRatios = shadowCascadeRatios; cascadeBorders = shadowCascadeBorders; }
         public void GetShadowAlgorithm(out int algorithm, out int variant, out int precision) { algorithm = shadowAlgorithm; variant = shadowVariant; precision = shadowPrecision; }
         public void SetShadowAlgorithm(int algorithm, int variant, int precision, int format, int[] data)
         {
 #pragma warning restore 414
         UnityEditor.SerializedProperty m_ShadowCascadeCount;
         UnityEditor.SerializedProperty m_ShadowCascadeRatios;
+        UnityEditor.SerializedProperty m_ShadowCascadeBorders;
 
         public static void SetRegistry( ShadowRegistry registry ) { m_ShadowRegistry = registry; }
 
             m_ShadowDatas     = serializedObject.FindProperty( "shadowDatas" );
             m_ShadowCascadeCount  = serializedObject.FindProperty( "shadowCascadeCount" );
             m_ShadowCascadeRatios = serializedObject.FindProperty( "shadowCascadeRatios" );
+            m_ShadowCascadeBorders = serializedObject.FindProperty( "shadowCascadeBorders" );
         }
         public override void OnInspectorGUI()
         {
                     int newcnt = m_ShadowCascadeCount.intValue <= 0 ? 1 : (m_ShadowCascadeCount.intValue > kMaxCascades ? kMaxCascades : m_ShadowCascadeCount.intValue);
                     m_ShadowCascadeCount.intValue = newcnt;
                     m_ShadowCascadeRatios.arraySize = newcnt-1;
+                    m_ShadowCascadeBorders.arraySize = newcnt;
+                }
+                for (int i = 0; i < m_ShadowCascadeBorders.arraySize; i++)
+                {
+                    UnityEditor.EditorGUILayout.Slider( m_ShadowCascadeBorders.GetArrayElementAtIndex( i ), 0.0f, 1.0f, new GUIContent( "Transition " + i ) );
                 }
                 UnityEditor.EditorGUI.indentLevel--;
             }

Assets/ScriptableRenderPipeline/Core/Shadow/Shadow.cs

         protected          uint[]                     m_TmpWidths  = new uint[ShadowmapBase.ShadowRequest.k_MaxFaceCount];
         protected          uint[]                     m_TmpHeights = new uint[ShadowmapBase.ShadowRequest.k_MaxFaceCount];
         protected          Vector4[]                  m_TmpSplits  = new Vector4[k_MaxCascadesInShader];
+        protected          float[]                    m_TmpScales  = new float[((k_MaxCascadesInShader+3)/4)*4];
+        protected          float[]                    m_TmpBorders = new float[((k_MaxCascadesInShader+3)/4)*4];
         protected          ShadowAlgoVector           m_SupportedAlgorithms = new ShadowAlgoVector( 0, false );
         protected          Material                   m_DebugMaterial = null;
 
 
             public bool IsValid() { return viewport.width > 0 && viewport.height > 0; }
         }
-        protected struct CachedEntry : IComparable<CachedEntry>
+        protected class CachedEntry : IComparable<CachedEntry>
         {
             public Key  key;
             public Data current;
 
             int     cascadeCnt = 0;
             float[] cascadeRatios = null;
+            float[] cascadeBorders = null;
             if( sr.shadowType == GPUShadowType.Directional )
             {
                 AdditionalShadowData asd = lights[sr.index].light.GetComponent<AdditionalShadowData>();
-                asd.GetShadowCascades( out cascadeCnt, out cascadeRatios );
+                asd.GetShadowCascades( out cascadeCnt, out cascadeRatios, out cascadeBorders );
             }
 
 
                     }
 
                     // read
+                    float texelSizeX = 1.0f, texelSizeY = 1.0f;
-                    Matrix4x4 vp;
+                    Matrix4x4 vp, invvp;
-                        vp = ShadowUtils.ExtractPointLightMatrix( lights[sr.index], key.faceIdx, 2.0f, out ce.current.view, out ce.current.proj, out ce.current.lightDir, out ce.current.splitData );
+                        vp = ShadowUtils.ExtractPointLightMatrix( lights[sr.index], key.faceIdx, 2.0f, out ce.current.view, out ce.current.proj, out invvp, out ce.current.lightDir, out ce.current.splitData );
-                        vp = ShadowUtils.ExtractSpotLightMatrix( lights[sr.index], out ce.current.view, out ce.current.proj, out ce.current.lightDir, out ce.current.splitData );
+                        vp = ShadowUtils.ExtractSpotLightMatrix( lights[sr.index], out ce.current.view, out ce.current.proj, out invvp, out ce.current.lightDir, out ce.current.splitData );
-                        vp = ShadowUtils.ExtractDirectionalLightMatrix( lights[sr.index], key.faceIdx, cascadeCnt, cascadeRatios, nearPlaneOffset, width, height, out ce.current.view, out ce.current.proj, out ce.current.lightDir, out ce.current.splitData, m_CullResults, (int) sr.index );
+                        vp = ShadowUtils.ExtractDirectionalLightMatrix( lights[sr.index], key.faceIdx, cascadeCnt, cascadeRatios, nearPlaneOffset, width, height, out ce.current.view, out ce.current.proj, out invvp, out ce.current.lightDir, out ce.current.splitData, m_CullResults, (int) sr.index );
+                        {
+                            int face = (int)key.faceIdx;
+                            texelSizeX = 2.0f / ce.current.proj.m00;
+                            texelSizeY = 2.0f / ce.current.proj.m11;
+                            m_TmpScales[face] = Mathf.Max( texelSizeX, texelSizeY );
+                            m_TmpBorders[face] = cascadeBorders[face];
+                        }
-                        vp = Matrix4x4.identity; // should never happen, though
+                        vp = invvp = Matrix4x4.identity; // should never happen, though
                     if (cameraRelativeRendering)
                     {
                         Vector3 camPosWS = camera.transform.position;
                     m_EntryCache[ceIdx] = ce;
 
                     sd.worldToShadow = vp.transpose; // apparently we need to transpose matrices that are sent to HLSL
+                    sd.shadowToWorld = invvp.transpose;
+                    sd.textureSize   = new Vector4( m_Width, m_Height, ce.current.viewport.width, ce.current.viewport.height );
                     sd.texelSizeRcp  = new Vector4( m_WidthRcp, m_HeightRcp, 1.0f / ce.current.viewport.width, 1.0f / ce.current.viewport.height );
                     sd.PackShadowmapId( m_TexSlot, m_SampSlot, ce.current.slice );
                     sd.PackShadowType( sr.shadowType, sanitizedAlgo );
         // Returns how many entries will be written into the payload buffer per light.
         virtual protected uint ReservePayload( ShadowRequest sr )
         {
-            uint payloadSize  = sr.shadowType == GPUShadowType.Directional ? k_MaxCascadesInShader : 0;
+            uint payloadSize  = sr.shadowType == GPUShadowType.Directional ? (k_MaxCascadesInShader + ((uint)m_TmpScales.Length / 4) + ((uint)m_TmpBorders.Length / 4)) : 0;
                  payloadSize += ShadowUtils.ExtractAlgorithm( sr.shadowAlgorithm ) == ShadowAlgorithm.PCF ? 1u : 0;
             return payloadSize;
         }
                 {
                     sp.Set( m_TmpSplits[i] );
                     payload[payloadOffset] = sp;
+                }
+
+                for( int i = 0; i < m_TmpScales.Length; i += 4 )
+                {
+                    sp.Set( m_TmpScales[i+0], m_TmpScales[i+1], m_TmpScales[i+2], m_TmpScales[i+3] );
+                    payload[payloadOffset] = sp;
+                    payloadOffset++;
+                }
+
+                for( int i = 0; i < m_TmpBorders.Length; i += 4 )
+                {
+                    sp.Set( m_TmpBorders[i+0], m_TmpBorders[i+1], m_TmpBorders[i+2], m_TmpBorders[i+3] );
+                    payload[payloadOffset] = sp;
+                    payloadOffset++;
                 }
             }
             ShadowAlgorithm algo; ShadowVariant vari; ShadowPrecision prec;
                 GPUShadowType shadowtype = GetShadowLightType(l);
                 // current bias value range is way too large, so scale by 0.01 for now until we've decided  whether to actually keep this value or not.
                 sd.bias = 0.01f * (SystemInfo.usesReversedZBuffer ? l.shadowBias : -l.shadowBias);
-                sd.normalBias = 100.0f * l.shadowNormalBias;
+                sd.normalBias = 2.0f * l.shadowNormalBias;
 
                 shadowIndices.AddUnchecked( (int) shadowDatas.Count() );
 

Assets/ScriptableRenderPipeline/Core/Shadow/ShadowBase.cs

     {
         // shadow texture related params (need to be set by ShadowmapBase and derivatives)
         public Matrix4x4     worldToShadow;  // to light space matrix
+        public Matrix4x4     shadowToWorld;  // from light space matrix
+        public Vector4       textureSize;    // the shadowmap's size in x and y. xy is texture relative, zw is viewport relative.
         public Vector4       texelSizeRcp;   // reciprocal of the shadowmap's texel size in x and y. xy is texture relative, zw is viewport relative.
         public uint          id;             // packed texture id, sampler id and slice idx
         public uint          shadowType;     // determines the shadow algorithm, i.e. which map to sample and how to interpret the data

Assets/ScriptableRenderPipeline/Core/Shadow/ShadowBase.cs.hlsl

 //
-// This file was automatically generated from Assets/ScriptableRenderPipeline/Core/Shadow/ShadowBase.cs.  Please don't edit by hand.
+// This file was automatically generated from Assets/ScriptableRenderPipeline/core/Shadow/ShadowBase.cs.  Please don't edit by hand.
 //
 
 #ifndef SHADOWBASE_CS_HLSL
 struct ShadowData
 {
     float4x4 worldToShadow;
+    float4x4 shadowToWorld;
+    float4 textureSize;
     float4 texelSizeRcp;
     uint id;
     uint shadowType;
 {
 	return value.worldToShadow;
 }
+float4x4 GetShadowToWorld(ShadowData value)
+{
+	return value.shadowToWorld;
+}
+}
+float4 GetTextureSize(ShadowData value)
+{
+	return value.textureSize;
 }
 float4 GetTexelSizeRcp(ShadowData value)
 {

Assets/ScriptableRenderPipeline/Core/Shadow/ShadowUtilities.cs

     }
     public class ShadowUtils
     {
-        public static Matrix4x4 ExtractSpotLightMatrix( VisibleLight vl, out Matrix4x4 view, out Matrix4x4 proj, out Vector4 lightDir, out ShadowSplitData splitData )
+        public static void InvertView( ref Matrix4x4 view, out Matrix4x4 invview )
+        {
+            invview = Matrix4x4.zero;
+            invview.m00 = view.m00; invview.m01 = view.m10; invview.m02 = view.m20;
+            invview.m10 = view.m01; invview.m11 = view.m11; invview.m12 = view.m21;
+            invview.m20 = view.m02; invview.m21 = view.m12; invview.m22 = view.m22;
+            invview.m33 = 1.0f;
+            invview.m03 = -(invview.m00 * view.m03 + invview.m01 * view.m13 + invview.m02 * view.m23);
+            invview.m13 = -(invview.m10 * view.m03 + invview.m11 * view.m13 + invview.m12 * view.m23);
+            invview.m23 = -(invview.m20 * view.m03 + invview.m21 * view.m13 + invview.m22 * view.m23);
+        }
+
+        public static void InvertOrthographic( ref Matrix4x4 proj, ref Matrix4x4 view, out Matrix4x4 vpinv )
+        {
+            Matrix4x4 invview;
+            InvertView( ref view, out invview );
+
+            Matrix4x4 invproj = Matrix4x4.zero;
+            invproj.m00 = 1.0f / proj.m00;
+            invproj.m11 = 1.0f / proj.m11;
+            invproj.m22 = 1.0f / proj.m22;
+            invproj.m33 = 1.0f;
+            invproj.m03 =   proj.m03 * invproj.m00;
+            invproj.m13 =   proj.m13 * invproj.m11;
+            invproj.m23 = - proj.m23 * invproj.m22;
+
+            vpinv = invview * invproj;
+        }
+
+        public static void InvertPerspective( ref Matrix4x4 proj, ref Matrix4x4 view, out Matrix4x4 vpinv )
+        {
+            Matrix4x4 invview;
+            InvertView(ref view, out invview);
+
+            Matrix4x4 invproj = Matrix4x4.zero;
+            invproj.m00 = 1.0f / proj.m00;
+            invproj.m03 = proj.m02 * invproj.m00;
+            invproj.m11 = 1.0f / proj.m11;
+            invproj.m13 = proj.m12 * invproj.m11;
+            invproj.m22 = 0.0f;
+            invproj.m23 = -1.0f;
+            invproj.m33 = proj.m22 / proj.m23;
+            invproj.m32 = invproj.m33 / proj.m22;
+
+            vpinv = invview * invproj;
+        }
+
+        public static Matrix4x4 ExtractSpotLightMatrix( VisibleLight vl, out Matrix4x4 view, out Matrix4x4 proj, out Matrix4x4 vpinverse, out Vector4 lightDir, out ShadowSplitData splitData )
         {
             splitData = new ShadowSplitData();
             splitData.cullingSphere.Set( 0.0f, 0.0f, 0.0f, float.NegativeInfinity );
             float fov = vl.spotAngle;
             proj = Matrix4x4.Perspective(fov, 1.0f, znear, zfar);
             // and the compound
+            InvertPerspective( ref proj, ref view, out vpinverse );
-        public static Matrix4x4 ExtractPointLightMatrix( VisibleLight vl, uint faceIdx, float fovBias, out Matrix4x4 view, out Matrix4x4 proj, out Vector4 lightDir, out ShadowSplitData splitData )
+        public static Matrix4x4 ExtractPointLightMatrix( VisibleLight vl, uint faceIdx, float fovBias, out Matrix4x4 view, out Matrix4x4 proj, out Matrix4x4 vpinverse, out Vector4 lightDir, out ShadowSplitData splitData )
         {
             Debug.Assert( faceIdx <= (uint) CubemapFace.NegativeZ, "Tried to extract cubemap face " + faceIdx + "." );
 
             float nearPlane = vl.light.shadowNearPlane >= nearmin ? vl.light.shadowNearPlane : nearmin;
             proj = Matrix4x4.Perspective( 90.0f + fovBias, 1.0f, nearPlane, farPlane );
             // and the compound
+            InvertPerspective( ref proj, ref view, out vpinverse );
-        public static Matrix4x4 ExtractDirectionalLightMatrix( VisibleLight vl, uint cascadeIdx, int cascadeCount, float[] splitRatio, float nearPlaneOffset, uint width, uint height, out Matrix4x4 view, out Matrix4x4 proj, out Vector4 lightDir, out ShadowSplitData splitData, CullResults cullResults, int lightIndex )
+        public static Matrix4x4 ExtractDirectionalLightMatrix( VisibleLight vl, uint cascadeIdx, int cascadeCount, float[] splitRatio, float nearPlaneOffset, uint width, uint height, out Matrix4x4 view, out Matrix4x4 proj, out Matrix4x4 vpinverse, out Vector4 lightDir, out ShadowSplitData splitData, CullResults cullResults, int lightIndex )
         {
             Debug.Assert( width == height, "Currently the cascaded shadow mapping code requires square cascades." );
             splitData = new ShadowSplitData();
                 ratios[i] = splitRatio[i];
             cullResults.ComputeDirectionalShadowMatricesAndCullingPrimitives( lightIndex, (int) cascadeIdx, cascadeCount, ratios, (int) width, nearPlaneOffset, out view, out proj, out splitData );
             // and the compound
+            InvertOrthographic( ref proj, ref view, out vpinverse );
             return proj * view;
         }
 

Assets/ScriptableRenderPipeline/Core/Shadow/VectorArray.cs

         {
             for (idx = 0; idx < m_count; ++idx)
             {
-                T obj = this[idx];
-                if (compareDelegate(ref designator, ref obj))
+                if (compareDelegate(ref designator, ref m_array[m_offset + idx]))
                     return true;
             }
             idx = k_InvalidIdx;
         {
             for (idx = 0; idx < m_count; ++idx)
             {
-                if (this[idx].Equals(designator))
+                if (m_array[m_offset + idx].Equals(designator))
                     return true;
             }
             idx = k_InvalidIdx;

Assets/ScriptableRenderPipeline/Fptl/ShadowDispatch.hlsl

 	SamplerComparisonState	compSamp = shadowContext.compSamplers[0];
 	uint					algo     = GPUSHADOWALGORITHM_PCF_9TAP;
 
-	return EvalShadow_CascadedDepth( shadowContext, algo, tex, compSamp, positionWS, normalWS, shadowDataIndex, L );
+	return EvalShadow_CascadedDepth_Blend( shadowContext, algo, tex, compSamp, positionWS, normalWS, shadowDataIndex, L );
 }
 
 float GetDirectionalShadowAttenuation( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float3 L, float2 unPositionSS )

Assets/ScriptableRenderPipeline/HDRenderPipeline/Debug/DebugDisplay.cs

         }
 
 
+        public bool IsDebugGBufferEnabled()
+        {
+            return m_DebugViewGBuffer != 0;
+        }
+
         public bool IsDebugDisplayEnabled()
         {
             return (m_DebugViewEngine != 0 || m_DebugViewMaterial != 0 || m_DebugViewVarying != Attributes.DebugViewVarying.None || m_DebugViewProperties != Attributes.DebugViewProperties.None || m_DebugViewGBuffer != 0);

Assets/ScriptableRenderPipeline/HDRenderPipeline/Debug/DebugViewMaterialGBuffer.shader

         Pass
         {
             ZWrite Off
-            Blend SrcAlpha OneMinusSrcAlpha // We will lerp only the values that are valid
 
             HLSLPROGRAM
             #pragma target 4.5
 
             // CAUTION: In case deferred lighting need to support various lighting model statically, we will require to do multicompile with different define like UNITY_MATERIAL_LIT
             #define UNITY_MATERIAL_LIT // Need to be define before including Material.hlsl
-            #include "../ShaderConfig.cs.hlsl"
             #include "../ShaderVariables.hlsl"
             #define DEBUG_DISPLAY
             #include "../Debug/DebugDisplay.hlsl"

Assets/ScriptableRenderPipeline/HDRenderPipeline/Debug/DebugViewTiles.shader

             #pragma fragment Frag
 
             #define LIGHTLOOP_TILE_PASS
-            #define LIGHTLOOP_TILE_ALL
 
             #pragma multi_compile USE_FPTL_LIGHTLIST USE_CLUSTERED_LIGHTLIST
             #pragma multi_compile SHOW_LIGHT_CATEGORIES SHOW_FEATURE_VARIANTS
             // deferred material must replace the old one here. If in the future we want to support multiple layout (cause a lot of consistency problem),
             // the deferred shader will require to use multicompile.
             #define UNITY_MATERIAL_LIT // Need to be define before including Material.hlsl
-            #include "../ShaderConfig.cs.hlsl"
             #include "../ShaderVariables.hlsl"
             #include "../Lighting/Lighting.hlsl" // This include Material.hlsl
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Editor/HDRenderPipelineInspector.cs

             EditorGUI.BeginChangeCheck();
 
             EditorGUILayout.PropertyField(m_enableTileAndCluster, styles.enableTileAndCluster);
-            EditorGUILayout.PropertyField(m_enableComputeLightEvaluation, styles.enableComputeLightEvaluation);
-            EditorGUILayout.PropertyField(m_enableComputeLightVariants, styles.enableComputeLightVariants);
-            EditorGUILayout.PropertyField(m_enableComputeMaterialVariants, styles.enableComputeMaterialVariants);
-            EditorGUILayout.PropertyField(m_enableClustered, styles.enableClustered);
-            EditorGUILayout.PropertyField(m_enableFptlForOpaqueWhenClustered, styles.enableFptlForOpaqueWhenClustered);
-            EditorGUILayout.PropertyField(m_enableBigTilePrepass, styles.enableBigTilePrepass);
+            if (m_enableTileAndCluster.boolValue)
+            {
+                EditorGUI.indentLevel++;
+                EditorGUILayout.PropertyField(m_enableBigTilePrepass, styles.enableBigTilePrepass);
+                EditorGUILayout.PropertyField(m_enableClustered, styles.enableClustered);
+
+                // Tag: SUPPORT_COMPUTE_CLUSTER_OPAQUE - Uncomment this if you want to do cluster opaque with compute shader (by default we support only fptl on opaque)
+                // if (m_enableClustered.boolValue)
+                if (m_enableClustered.boolValue && !m_enableComputeLightEvaluation.boolValue)
+                {
+                    EditorGUI.indentLevel++;
+                    EditorGUILayout.PropertyField(m_enableFptlForOpaqueWhenClustered, styles.enableFptlForOpaqueWhenClustered);
+                    EditorGUI.indentLevel--;
+                }
+                EditorGUILayout.PropertyField(m_enableComputeLightEvaluation, styles.enableComputeLightEvaluation);
+                if (m_enableComputeLightEvaluation.boolValue)
+                {
+                    // Tag: SUPPORT_COMPUTE_CLUSTER_OPAQUE - Uncomment this if you want to do cluster opaque with compute shader (by default we support only fptl on opaque)
+                    m_enableFptlForOpaqueWhenClustered.boolValue = true; // Force fptl to be always true if compute evaluation is enable
+
+                    EditorGUI.indentLevel++;
+                    EditorGUILayout.PropertyField(m_enableComputeLightVariants, styles.enableComputeLightVariants);
+                    EditorGUILayout.PropertyField(m_enableComputeMaterialVariants, styles.enableComputeMaterialVariants);
+                    EditorGUI.indentLevel--;
+                }
+            }
+
 
             if (EditorGUI.EndChangeCheck())
             {

Assets/ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipeline.cs

 
         public void SetupGlobalParams(CommandBuffer cmd)
         {
-            cmd.SetGlobalMatrix("_ViewMatrix",                viewMatrix);
-            cmd.SetGlobalMatrix("_InvViewMatrix",             viewMatrix.inverse);
-            cmd.SetGlobalMatrix("_ProjMatrix",                projMatrix);
-            cmd.SetGlobalMatrix("_InvProjMatrix",             projMatrix.inverse);
-            cmd.SetGlobalMatrix("_NonJitteredViewProjMatrix", nonJitteredViewProjMatrix);
-            cmd.SetGlobalMatrix("_ViewProjMatrix",            viewProjMatrix);
-            cmd.SetGlobalMatrix("_InvViewProjMatrix",         viewProjMatrix.inverse);
-            cmd.SetGlobalVector("_InvProjParam",              invProjParam);
-            cmd.SetGlobalVector("_ScreenSize",                screenSize);
-            cmd.SetGlobalMatrix("_PrevViewProjMatrix",        prevViewProjMatrix);
-            cmd.SetGlobalVectorArray("_FrustumPlanes",        frustumPlaneEquations);
+            cmd.SetGlobalMatrix(HDShaderIDs._ViewMatrix,                viewMatrix);
+            cmd.SetGlobalMatrix(HDShaderIDs._InvViewMatrix,             viewMatrix.inverse);
+            cmd.SetGlobalMatrix(HDShaderIDs._ProjMatrix,                projMatrix);
+            cmd.SetGlobalMatrix(HDShaderIDs._InvProjMatrix,             projMatrix.inverse);
+            cmd.SetGlobalMatrix(HDShaderIDs._NonJitteredViewProjMatrix, nonJitteredViewProjMatrix);
+            cmd.SetGlobalMatrix(HDShaderIDs._ViewProjMatrix,            viewProjMatrix);
+            cmd.SetGlobalMatrix(HDShaderIDs._InvViewProjMatrix,         viewProjMatrix.inverse);
+            cmd.SetGlobalVector(HDShaderIDs._InvProjParam,              invProjParam);
+            cmd.SetGlobalVector(HDShaderIDs._ScreenSize,                screenSize);
+            cmd.SetGlobalMatrix(HDShaderIDs._PrevViewProjMatrix,        prevViewProjMatrix);
+            cmd.SetGlobalVectorArray(HDShaderIDs._FrustumPlanes,        frustumPlaneEquations);
-            material.SetMatrix("_ViewMatrix",                viewMatrix);
-            material.SetMatrix("_InvViewMatrix",             viewMatrix.inverse);
-            material.SetMatrix("_ProjMatrix",                projMatrix);
-            material.SetMatrix("_InvProjMatrix",             projMatrix.inverse);
-            material.SetMatrix("_NonJitteredViewProjMatrix", nonJitteredViewProjMatrix);
-            material.SetMatrix("_ViewProjMatrix",            viewProjMatrix);
-            material.SetMatrix("_InvViewProjMatrix",         viewProjMatrix.inverse);
-            material.SetVector("_InvProjParam",              invProjParam);
-            material.SetVector("_ScreenSize",                screenSize);
-            material.SetMatrix("_PrevViewProjMatrix",        prevViewProjMatrix);
-            material.SetVectorArray("_FrustumPlanes",        frustumPlaneEquations);
+            material.SetMatrix(HDShaderIDs._ViewMatrix,                viewMatrix);
+            material.SetMatrix(HDShaderIDs._InvViewMatrix,             viewMatrix.inverse);
+            material.SetMatrix(HDShaderIDs._ProjMatrix,                projMatrix);
+            material.SetMatrix(HDShaderIDs._InvProjMatrix,             projMatrix.inverse);
+            material.SetMatrix(HDShaderIDs._NonJitteredViewProjMatrix, nonJitteredViewProjMatrix);
+            material.SetMatrix(HDShaderIDs._ViewProjMatrix,            viewProjMatrix);
+            material.SetMatrix(HDShaderIDs._InvViewProjMatrix,         viewProjMatrix.inverse);
+            material.SetVector(HDShaderIDs._InvProjParam,              invProjParam);
+            material.SetVector(HDShaderIDs._ScreenSize,                screenSize);
+            material.SetMatrix(HDShaderIDs._PrevViewProjMatrix,        prevViewProjMatrix);
+            material.SetVectorArray(HDShaderIDs._FrustumPlanes,        frustumPlaneEquations);
-            cmd.SetComputeMatrixParam(cs, "_ViewMatrix",                viewMatrix);
-            cmd.SetComputeMatrixParam(cs, "_InvViewMatrix",             viewMatrix.inverse);
-            cmd.SetComputeMatrixParam(cs, "_ProjMatrix",                projMatrix);
-            cmd.SetComputeMatrixParam(cs, "_InvProjMatrix",             projMatrix.inverse);
-            cmd.SetComputeMatrixParam(cs, "_NonJitteredViewProjMatrix", nonJitteredViewProjMatrix);
-            cmd.SetComputeMatrixParam(cs, "_ViewProjMatrix",            viewProjMatrix);
-            cmd.SetComputeMatrixParam(cs, "_InvViewProjMatrix",         viewProjMatrix.inverse);
-            cmd.SetComputeVectorParam(cs, "_InvProjParam",              invProjParam);
-            cmd.SetComputeVectorParam(cs, "_ScreenSize",                screenSize);
-            cmd.SetComputeMatrixParam(cs, "_PrevViewProjMatrix",        prevViewProjMatrix);
-            cmd.SetComputeVectorArrayParam(cs, "_FrustumPlanes",        frustumPlaneEquations);
+            cmd.SetComputeMatrixParam(cs, HDShaderIDs._ViewMatrix,                viewMatrix);
+            cmd.SetComputeMatrixParam(cs, HDShaderIDs._InvViewMatrix,             viewMatrix.inverse);
+            cmd.SetComputeMatrixParam(cs, HDShaderIDs._ProjMatrix,                projMatrix);
+            cmd.SetComputeMatrixParam(cs, HDShaderIDs._InvProjMatrix,             projMatrix.inverse);
+            cmd.SetComputeMatrixParam(cs, HDShaderIDs._NonJitteredViewProjMatrix, nonJitteredViewProjMatrix);
+            cmd.SetComputeMatrixParam(cs, HDShaderIDs._ViewProjMatrix,            viewProjMatrix);
+            cmd.SetComputeMatrixParam(cs, HDShaderIDs._InvViewProjMatrix,         viewProjMatrix.inverse);
+            cmd.SetComputeVectorParam(cs, HDShaderIDs._InvProjParam,              invProjParam);
+            cmd.SetComputeVectorParam(cs, HDShaderIDs._ScreenSize,                screenSize);
+            cmd.SetComputeMatrixParam(cs, HDShaderIDs._PrevViewProjMatrix,        prevViewProjMatrix);
+            cmd.SetComputeVectorArrayParam(cs, HDShaderIDs._FrustumPlanes,        frustumPlaneEquations);
+            // Copy values set by Unity which are not configured in scripts.
+            cmd.SetComputeVectorParam(cs, HDShaderIDs.unity_OrthoParams,    Shader.GetGlobalVector(HDShaderIDs.unity_OrthoParams));
+            cmd.SetComputeVectorParam(cs, HDShaderIDs._ProjectionParams,    Shader.GetGlobalVector(HDShaderIDs._ProjectionParams));
+            cmd.SetComputeVectorParam(cs, HDShaderIDs._ScreenParams,        Shader.GetGlobalVector(HDShaderIDs._ScreenParams));
+            cmd.SetComputeVectorParam(cs, HDShaderIDs._ZBufferParams,       Shader.GetGlobalVector(HDShaderIDs._ZBufferParams));
+            cmd.SetComputeVectorParam(cs, HDShaderIDs._WorldSpaceCameraPos, Shader.GetGlobalVector(HDShaderIDs._WorldSpaceCameraPos));
         }
     }
 
 
         readonly GBufferManager m_gbufferManager = new GBufferManager();
 
-        Material m_CopyStencilBuffer;
+        Material m_CopyStencilForSplitLighting;
+        Material m_CopyStencilForRegularLighting;
-        Material m_FilterAndCombineSubsurfaceScattering;
+        ComputeShader m_SubsurfaceScatteringCS { get { return m_Asset.renderPipelineResources.subsurfaceScatteringCS; } }
+        int m_SubsurfaceScatteringKernel;
-        Material m_FilterSubsurfaceScattering;
+        Material m_SssVerticalFilterPass;
+        Material m_SssHorizontalFilterAndCombinePass;
         // <<< Old SSS Model
 
         Material m_CameraMotionVectorsMaterial;
 
         // Various buffer
         readonly int m_CameraColorBuffer;
-        readonly int m_CameraSubsurfaceBuffer;
+        readonly int m_CameraDiffuseIrradianceBuffer;
         // Old SSS Model >>>
         readonly int m_CameraFilteringBuffer;
         // <<< Old SSS Model
         // 'm_CameraColorBuffer' does not contain diffuse lighting of SSS materials until the SSS pass.
         // It is stored within 'm_CameraSubsurfaceBufferRT'.
         readonly RenderTargetIdentifier m_CameraColorBufferRT;
-        readonly RenderTargetIdentifier m_CameraSubsurfaceBufferRT;
+        readonly RenderTargetIdentifier m_CameraDiffuseIrradianceBufferRT;
         // Old SSS Model >>>
         readonly RenderTargetIdentifier m_CameraFilteringBufferRT;
         // <<< Old SSS Model
         private RenderTexture m_CameraDepthStencilBuffer = null;
         private RenderTexture m_CameraDepthBufferCopy = null;
-        private RenderTexture m_CameraStencilBufferCopy = null; // Currently, it's manually copied using a pixel shader, and optimized to only contain the SSS bit
+        private RenderTexture m_CameraStencilBufferCopy = null;
+        private RenderTexture m_HTile = null;                   // If the hardware does not expose it, we compute our own, optimized to only contain the SSS bit
+        private RenderTargetIdentifier m_HTileRT;
 
         // Post-processing context and screen-space effects (recycled on every frame to avoid GC alloc)
         readonly PostProcessRenderContext m_PostProcessContext;
             // whereas it work. Don't know what is hapening, DebugDisplay use the same code and name is correct there.
             // Debug.Assert(m_DeferredMaterial != null);
 
-            m_CameraColorBuffer             = Shader.PropertyToID("_CameraColorTexture");
-            m_CameraSubsurfaceBuffer        = Shader.PropertyToID("_CameraSubsurfaceTexture");
+            m_CameraColorBuffer               = HDShaderIDs._CameraColorTexture;
+            m_CameraColorBufferRT             = new RenderTargetIdentifier(m_CameraColorBuffer);
+            m_CameraDiffuseIrradianceBuffer   = HDShaderIDs._CameraDiffuseIrradianceTexture;
+            m_CameraDiffuseIrradianceBufferRT = new RenderTargetIdentifier(m_CameraDiffuseIrradianceBuffer);
-            m_CameraColorBufferRT      = new RenderTargetIdentifier(m_CameraColorBuffer);
-            m_CameraSubsurfaceBufferRT = new RenderTargetIdentifier(m_CameraSubsurfaceBuffer);
-            m_CameraFilteringBuffer   = Shader.PropertyToID("_CameraFilteringBuffer");
+            m_CameraFilteringBuffer   = HDShaderIDs._CameraFilteringBuffer;
-            m_CopyStencilBuffer           = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/CopyStencilBuffer");
-            m_CameraMotionVectorsMaterial = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/CameraMotionVectors");
+            m_CopyStencilForSplitLighting   = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/CopyStencilBuffer");
+            m_CopyStencilForSplitLighting.EnableKeyword("EXPORT_HTILE");
+            m_CopyStencilForSplitLighting.SetInt(HDShaderIDs._StencilRef, (int)StencilLightingUsage.SplitLighting);
+            m_CopyStencilForRegularLighting = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/CopyStencilBuffer");
+            m_CopyStencilForRegularLighting.DisableKeyword("EXPORT_HTILE");
+            m_CopyStencilForRegularLighting.SetInt(HDShaderIDs._StencilRef, (int)StencilLightingUsage.RegularLighting);
+            m_CameraMotionVectorsMaterial   = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/CameraMotionVectors");
 
             InitializeDebugMaterials();
 
                 m_gbufferManager.SetBufferDescription(gbufferIndex, "_GBufferTexture" + gbufferIndex, RTFormat[gbufferIndex], RTReadWrite[gbufferIndex]);
             }
 
-            m_VelocityBuffer = Shader.PropertyToID("_VelocityTexture");
+            m_VelocityBuffer = HDShaderIDs._VelocityTexture;
             if (ShaderConfig.s_VelocityInGbuffer == 1)
             {
                 // If velocity is in GBuffer then it is in the last RT. Assign a different name to it.
             m_VelocityBufferRT = new RenderTargetIdentifier(m_VelocityBuffer);
 
-            m_DistortionBuffer = Shader.PropertyToID("_DistortionTexture");
+            m_DistortionBuffer = HDShaderIDs._DistortionTexture;
             m_DistortionBufferRT = new RenderTargetIdentifier(m_DistortionBuffer);
 
             m_MaterialList.ForEach(material => material.Build(asset.renderPipelineResources));
             m_SsaoEffect.Build(asset.renderPipelineResources);
 
             m_DebugDisplaySettings.RegisterDebug();
-            m_DebugFullScreenTempRT = Shader.PropertyToID("_DebugFullScreenTexture");
+            m_DebugFullScreenTempRT = HDShaderIDs._DebugFullScreenTexture;
         }
 
         void InitializeDebugMaterials()
             m_DebugFullScreen = Utilities.CreateEngineMaterial(m_Asset.renderPipelineResources.debugFullScreenShader);
         }
 
-        // Old SSS Model >>>
-            Utilities.Destroy(m_FilterSubsurfaceScattering);
-            m_FilterSubsurfaceScattering = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/CombineSubsurfaceScattering");
-            Utilities.SelectKeyword(m_FilterSubsurfaceScattering, "SSS_MODEL_DISNEY", "SSS_MODEL_BASIC", useDisneySSS);
-            m_FilterSubsurfaceScattering.DisableKeyword("SSS_FILTER_HORIZONTAL_AND_COMBINE");
-            m_FilterSubsurfaceScattering.SetFloat("_DstBlend", (float)BlendMode.Zero);
+            m_SubsurfaceScatteringKernel = m_SubsurfaceScatteringCS.FindKernel("SubsurfaceScattering");
-            Utilities.Destroy(m_FilterAndCombineSubsurfaceScattering);
-            m_FilterAndCombineSubsurfaceScattering = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/CombineSubsurfaceScattering");
-            Utilities.SelectKeyword(m_FilterAndCombineSubsurfaceScattering, "SSS_MODEL_DISNEY", "SSS_MODEL_BASIC", useDisneySSS);
-            m_FilterAndCombineSubsurfaceScattering.EnableKeyword("SSS_FILTER_HORIZONTAL_AND_COMBINE");
-            m_FilterAndCombineSubsurfaceScattering.SetFloat("_DstBlend", (float)BlendMode.One);
+            // Old SSS Model >>>
+            Utilities.Destroy(m_SssVerticalFilterPass);
+            m_SssVerticalFilterPass = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/SubsurfaceScattering");
+            m_SssVerticalFilterPass.DisableKeyword("SSS_FILTER_HORIZONTAL_AND_COMBINE");
+            m_SssVerticalFilterPass.SetFloat(HDShaderIDs._DstBlend, (float)BlendMode.Zero);
+
+            Utilities.Destroy(m_SssHorizontalFilterAndCombinePass);
+            m_SssHorizontalFilterAndCombinePass = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/SubsurfaceScattering");
+            m_SssHorizontalFilterAndCombinePass.EnableKeyword("SSS_FILTER_HORIZONTAL_AND_COMBINE");
+            m_SssHorizontalFilterAndCombinePass.SetFloat(HDShaderIDs._DstBlend, (float)BlendMode.One);
+            // <<< Old SSS Model
-        // <<< Old SSS Model
 
         public void OnSceneLoad()
         {
                 {
                     m_CameraStencilBufferCopy.Release();
                 }
-                m_CameraStencilBufferCopy = new RenderTexture(camera.pixelWidth, camera.pixelHeight, 0, RenderTextureFormat.R8);
+                m_CameraStencilBufferCopy = new RenderTexture(camera.pixelWidth, camera.pixelHeight, 0, RenderTextureFormat.R8, RenderTextureReadWrite.Linear); // DXGI_FORMAT_R8_UINT is not supported by Unity
+
+            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)
                 if (m_SkyManager.IsSkyValid())
                 {
                     m_SkyManager.SetGlobalSkyTexture();
-                    Shader.SetGlobalInt("_EnvLightSkyEnabled", 1);
+                    Shader.SetGlobalInt(HDShaderIDs._EnvLightSkyEnabled, 1);
-                    Shader.SetGlobalInt("_EnvLightSkyEnabled", 0);
+                    Shader.SetGlobalInt(HDShaderIDs._EnvLightSkyEnabled, 0);
-                Shader.SetGlobalInt(     "_EnableSSSAndTransmission",          m_DebugDisplaySettings.renderingDebugSettings.enableSSSAndTransmission ? 1 : 0);
-                Shader.SetGlobalInt(     "_TexturingModeFlags", (int)sssParameters.texturingModeFlags);
-                Shader.SetGlobalInt(     "_TransmissionFlags",  (int)sssParameters.transmissionFlags);
-                cmd.SetGlobalVectorArray( "_ThicknessRemaps",        sssParameters.thicknessRemaps);
+                Shader.SetGlobalInt(HDShaderIDs._EnableSSSAndTransmission,          m_DebugDisplaySettings.renderingDebugSettings.enableSSSAndTransmission ? 1 : 0);
+                Shader.SetGlobalInt(HDShaderIDs._TexturingModeFlags, (int)sssParameters.texturingModeFlags);
+                Shader.SetGlobalInt(HDShaderIDs._TransmissionFlags,  (int)sssParameters.transmissionFlags);
+                cmd.SetGlobalVectorArray(HDShaderIDs._ThicknessRemaps,        sssParameters.thicknessRemaps);
-                cmd.SetGlobalVectorArray("_ShapeParams",             sssParameters.useDisneySSS ? sssParameters.shapeParams : sssParameters.halfRcpWeightedVariances);
-                cmd.SetGlobalVectorArray("_TransmissionTints",       sssParameters.transmissionTints);
+                cmd.SetGlobalVectorArray(HDShaderIDs._ShapeParams,             sssParameters.useDisneySSS ? sssParameters.shapeParams : sssParameters.halfRcpWeightedVariances);
+                cmd.SetGlobalVectorArray(HDShaderIDs._TransmissionTints,       sssParameters.transmissionTints);
             }
         }
 
         bool NeedStencilBufferCopy()
         {
             // Currently, Unity does not offer a way to bind the stencil buffer as a texture in a compute shader.
-            // Therefore, it's manually copied using a pixel shader, and optimized to only contain the SSS bit.
+            // Therefore, it's manually copied using a pixel shader.
+            return m_DebugDisplaySettings.renderingDebugSettings.enableSSSAndTransmission || LightLoop.GetFeatureVariantsEnabled(m_Asset.tileSettings);
+        }
+
+        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_DebugDisplaySettings.renderingDebugSettings.enableSSSAndTransmission;
         }
 
             return NeedStencilBufferCopy() ? m_CameraStencilBufferCopyRT : m_CameraDepthStencilBufferRT;
         }
 
+        RenderTargetIdentifier GetHTile()
+        {
+            // Currently, Unity does not offer a way to access the GCN HTile.
+            return m_HTileRT;
+        }
+
         private void CopyDepthBufferIfNeeded(CommandBuffer cmd)
         {
             using (new Utilities.ProfilingSample(NeedDepthBufferCopy() ? "Copy DepthBuffer" : "Set DepthBuffer", cmd))
                     }
                 }
 
-                cmd.SetGlobalTexture("_MainDepthTexture", GetDepthTexture());
+                cmd.SetGlobalTexture(HDShaderIDs._MainDepthTexture, GetDepthTexture());
             }
         }
 
             {
                 using (new Utilities.ProfilingSample("Copy StencilBuffer", cmd))
                 {
-                    Utilities.DrawFullScreen(cmd, m_CopyStencilBuffer, m_CameraStencilBufferCopyRT, m_CameraDepthStencilBufferRT);
+                    cmd.SetRandomWriteTarget(1, GetHTile());
+                    // Our method of exporting the stencil requires one pass per unique stencil value.
+                    Utilities.DrawFullScreen(cmd, m_CopyStencilForSplitLighting,   m_CameraStencilBufferCopyRT, m_CameraDepthStencilBufferRT);
+                    Utilities.DrawFullScreen(cmd, m_CopyStencilForRegularLighting, m_CameraStencilBufferCopyRT, m_CameraDepthStencilBufferRT);
+                    cmd.ClearRandomWriteTargets();
-            cmd.SetGlobalTexture("_StencilTexture", GetStencilTexture());
+            cmd.SetGlobalTexture(HDShaderIDs._HTile, GetHTile());
+            cmd.SetGlobalTexture(HDShaderIDs._StencilTexture, GetStencilTexture());
         }
 
         public void UpdateCommonSettings()
                 CopyDepthBufferIfNeeded(cmd);
             }
 
-            // Required for the SSS pass.
+            // Required for the SSS and the shader feature classification pass.
             PrepareAndBindStencilTexture(cmd);
 
             if (m_DebugDisplaySettings.IsDebugMaterialDisplayEnabled())
                     m_LightLoop.PrepareLightsForGPU(m_ShadowSettings, m_CullResults, camera);
                     m_LightLoop.RenderShadows(renderContext, cmd, m_CullResults);
                     renderContext.SetupCameraProperties(camera); // Need to recall SetupCameraProperties after m_ShadowPass.Render
-                    m_LightLoop.BuildGPULightLists(camera, cmd, m_CameraDepthStencilBufferRT);
+                    m_LightLoop.BuildGPULightLists(camera, cmd, m_CameraDepthStencilBufferRT, GetStencilTexture());
                 }
 
                 // Caution: We require sun light here as some sky use the sun light to render, mean UpdateSkyEnvironment
                 // We compute subsurface scattering here. Therefore, no objects rendered afterwards will exhibit SSS.
                 // Currently, there is no efficient way to switch between SRT and MRT for the forward pass;
                 // therefore, forward-rendered objects do not output split lighting required for the SSS pass.
-                CombineSubsurfaceScattering(hdCamera, cmd, m_Asset.sssSettings);
+                SubsurfaceScatteringPass(hdCamera, cmd, m_Asset.sssSettings);
 
                 // For opaque forward we have split rendering in two categories
                 // Material that are always forward and material that can be deferred or forward depends on render pipeline options (like switch to rendering forward only mode)
         {
             using (new Utilities.ProfilingSample("DisplayDebug ViewMaterial", cmd))
             {
-                // Render Opaque forward
-                Utilities.SetRenderTarget(cmd, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT, Utilities.kClearAll, Color.black);
-                RenderOpaqueRenderList(cull, hdCamera.camera, renderContext, cmd, "ForwardDisplayDebug", Utilities.kRendererConfigurationBakedLighting);
-
-                // Render GBuffer opaque
-                if (!m_Asset.renderingSettings.ShouldUseForwardRenderingOnly())
+                if(m_DebugDisplaySettings.materialDebugSettings.IsDebugGBufferEnabled() && !m_Asset.renderingSettings.ShouldUseForwardRenderingOnly())
-                        cmd.Blit(null, m_CameraColorBufferRT, m_DebugViewMaterialGBuffer, 0);
+                        Utilities.DrawFullScreen(cmd, m_DebugViewMaterialGBuffer, m_CameraColorBufferRT);
-
-                // Render forward transparent
+                else
+                    Utilities.SetRenderTarget(cmd, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT, Utilities.kClearAll, Color.black);
+                    // Render Opaque forward
+                    RenderOpaqueRenderList(cull, hdCamera.camera, renderContext, cmd, "ForwardDisplayDebug", Utilities.kRendererConfigurationBakedLighting);
+
+                    // Render forward transparent
                     RenderTransparentRenderList(cull, hdCamera.camera, renderContext, cmd, "ForwardDisplayDebug", Utilities.kRendererConfigurationBakedLighting);
                 }
             }
                 return;
             }
 
-            RenderTargetIdentifier[] colorRTs     = { m_CameraColorBufferRT, m_CameraSubsurfaceBufferRT };
+            RenderTargetIdentifier[] colorRTs     = { m_CameraColorBufferRT, m_CameraDiffuseIrradianceBufferRT };
             RenderTargetIdentifier   depthTexture = GetDepthTexture();
 
             if (m_DebugDisplaySettings.renderingDebugSettings.enableSSSAndTransmission)
         }
 
         // Combines specular lighting and diffuse lighting with subsurface scattering.
-        void CombineSubsurfaceScattering(HDCamera hdCamera, CommandBuffer cmd, SubsurfaceScatteringSettings sssParameters)
+        void SubsurfaceScatteringPass(HDCamera hdCamera, CommandBuffer cmd, SubsurfaceScatteringSettings sssParameters)
         {
             // Currently, forward-rendered objects do not output split lighting required for the SSS pass.
             if (!m_DebugDisplaySettings.renderingDebugSettings.enableSSSAndTransmission || m_Asset.renderingSettings.ShouldUseForwardRenderingOnly())
             {
                 if (sssSettings.useDisneySSS)
                 {
-                    cmd.SetGlobalTexture("_IrradianceSource", m_CameraSubsurfaceBufferRT); // Cannot set a RT on a material
-                    m_FilterAndCombineSubsurfaceScattering.SetFloatArray("_WorldScales",            sssParameters.worldScales);
-                    m_FilterAndCombineSubsurfaceScattering.SetFloatArray("_FilterKernelsNearField", sssParameters.filterKernelsNearField);
-                    m_FilterAndCombineSubsurfaceScattering.SetFloatArray("_FilterKernelsFarField",  sssParameters.filterKernelsFarField);
+                    hdCamera.SetupComputeShader(m_SubsurfaceScatteringCS, cmd);
+
+                    cmd.SetComputeIntParam(        m_SubsurfaceScatteringCS, HDShaderIDs._TexturingModeFlags, sssParameters.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);
-                    Utilities.DrawFullScreen(cmd, m_FilterAndCombineSubsurfaceScattering, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT);
+                    cmd.SetComputeTextureParam(m_SubsurfaceScatteringCS, m_SubsurfaceScatteringKernel, HDShaderIDs._GBufferTexture0,    m_gbufferManager.GetGBuffers()[0]);
+                    cmd.SetComputeTextureParam(m_SubsurfaceScatteringCS, m_SubsurfaceScatteringKernel, HDShaderIDs._GBufferTexture1,    m_gbufferManager.GetGBuffers()[1]);
+                    cmd.SetComputeTextureParam(m_SubsurfaceScatteringCS, m_SubsurfaceScatteringKernel, HDShaderIDs._GBufferTexture2,    m_gbufferManager.GetGBuffers()[2]);
+                    cmd.SetComputeTextureParam(m_SubsurfaceScatteringCS, m_SubsurfaceScatteringKernel, HDShaderIDs._GBufferTexture3,    m_gbufferManager.GetGBuffers()[3]);
+                    cmd.SetComputeTextureParam(m_SubsurfaceScatteringCS, m_SubsurfaceScatteringKernel, HDShaderIDs._DepthTexture,       GetDepthTexture());
+                    cmd.SetComputeTextureParam(m_SubsurfaceScatteringCS, m_SubsurfaceScatteringKernel, HDShaderIDs._StencilTexture,     GetStencilTexture());
+                    cmd.SetComputeTextureParam(m_SubsurfaceScatteringCS, m_SubsurfaceScatteringKernel, HDShaderIDs._HTile,              GetHTile());
+                    cmd.SetComputeTextureParam(m_SubsurfaceScatteringCS, m_SubsurfaceScatteringKernel, HDShaderIDs._IrradianceSource,   m_CameraDiffuseIrradianceBufferRT);
+                    cmd.SetComputeTextureParam(m_SubsurfaceScatteringCS, m_SubsurfaceScatteringKernel, HDShaderIDs._CameraColorTexture, m_CameraColorBufferRT);
+
+                    cmd.DispatchCompute(m_SubsurfaceScatteringCS, m_SubsurfaceScatteringKernel, ((int)hdCamera.screenSize.x + 15) / 16, ((int)hdCamera.screenSize.y + 15) / 16, 1);
-                    cmd.SetGlobalTexture("_IrradianceSource", m_CameraSubsurfaceBufferRT);  // Cannot set a RT on a material
-                    m_FilterSubsurfaceScattering.SetFloatArray("_WorldScales",               sssParameters.worldScales);
-                    m_FilterSubsurfaceScattering.SetVectorArray("_FilterKernelsBasic",       sssParameters.filterKernelsBasic);
-                    m_FilterSubsurfaceScattering.SetVectorArray("_HalfRcpWeightedVariances", sssParameters.halfRcpWeightedVariances);
-                    Utilities.DrawFullScreen(cmd, m_FilterSubsurfaceScattering, m_CameraFilteringBufferRT, m_CameraDepthStencilBufferRT);
+                    cmd.SetGlobalTexture(HDShaderIDs._IrradianceSource, m_CameraDiffuseIrradianceBufferRT);  // Cannot set a RT on a material
+                    m_SssVerticalFilterPass.SetVectorArray(HDShaderIDs._WorldScales,              sssParameters.worldScales);
+                    m_SssVerticalFilterPass.SetVectorArray(HDShaderIDs._FilterKernelsBasic,       sssParameters.filterKernelsBasic);
+                    m_SssVerticalFilterPass.SetVectorArray(HDShaderIDs._HalfRcpWeightedVariances, sssParameters.halfRcpWeightedVariances);
+                    Utilities.DrawFullScreen(cmd, m_SssVerticalFilterPass, m_CameraFilteringBufferRT, m_CameraDepthStencilBufferRT);
-                    cmd.SetGlobalTexture("_IrradianceSource", m_CameraFilteringBufferRT);  // Cannot set a RT on a material
-                    m_FilterAndCombineSubsurfaceScattering.SetFloatArray("_WorldScales",               sssParameters.worldScales);
-                    m_FilterAndCombineSubsurfaceScattering.SetVectorArray("_FilterKernelsBasic",       sssParameters.filterKernelsBasic);
-                    m_FilterAndCombineSubsurfaceScattering.SetVectorArray("_HalfRcpWeightedVariances", sssParameters.halfRcpWeightedVariances);
-                    Utilities.DrawFullScreen(cmd, m_FilterAndCombineSubsurfaceScattering, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT);
+                    cmd.SetGlobalTexture(HDShaderIDs._IrradianceSource, m_CameraFilteringBufferRT);  // Cannot set a RT on a material
+                    m_SssHorizontalFilterAndCombinePass.SetVectorArray(HDShaderIDs._WorldScales,              sssParameters.worldScales);
+                    m_SssHorizontalFilterAndCombinePass.SetVectorArray(HDShaderIDs._FilterKernelsBasic,       sssParameters.filterKernelsBasic);
+                    m_SssHorizontalFilterAndCombinePass.SetVectorArray(HDShaderIDs._HalfRcpWeightedVariances, sssParameters.halfRcpWeightedVariances);
+                    Utilities.DrawFullScreen(cmd, m_SssHorizontalFilterAndCombinePass, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT);
                 }
             }
         }
                 int w = (int)hdcam.screenSize.x;
                 int h = (int)hdcam.screenSize.y;
 
-                m_CameraMotionVectorsMaterial.SetVector("_CameraPosDiff", hdcam.prevCameraPos - hdcam.cameraPos);
+                m_CameraMotionVectorsMaterial.SetVector(HDShaderIDs._CameraPosDiff, hdcam.prevCameraPos - hdcam.cameraPos);
 
                 cmd.GetTemporaryRT(m_VelocityBuffer, w, h, 0, FilterMode.Point, Builtin.GetVelocityBufferFormat(), Builtin.GetVelocityBufferReadWrite());
                 Utilities.DrawFullScreen(cmd, m_CameraMotionVectorsMaterial, m_VelocityBufferRT, null, 0);
             {
                 if (Utilities.IsPostProcessingActive(layer))
                 {
-                    cmd.SetGlobalTexture("_CameraDepthTexture", GetDepthTexture());
-                    cmd.SetGlobalTexture("_CameraMotionVectorsTexture", m_VelocityBufferRT);
+                    cmd.SetGlobalTexture(HDShaderIDs._CameraDepthTexture, GetDepthTexture());
+                    cmd.SetGlobalTexture(HDShaderIDs._CameraMotionVectorsTexture, m_VelocityBufferRT);
 
                     var context = m_PostProcessContext;
                     context.Reset();
             Vector4 debugAlbedo = new Vector4(lightingDebugSettings.debugLightingAlbedo.r, lightingDebugSettings.debugLightingAlbedo.g, lightingDebugSettings.debugLightingAlbedo.b, 0.0f);
             Vector4 debugSmoothness = new Vector4(lightingDebugSettings.overrideSmoothness ? 1.0f : 0.0f, lightingDebugSettings.overrideSmoothnessValue, 0.0f, 0.0f);
 
-            Shader.SetGlobalInt("_DebugViewMaterial", (int)m_DebugDisplaySettings.GetDebugMaterialIndex());
-            Shader.SetGlobalInt("_DebugLightingMode", (int)m_DebugDisplaySettings.GetDebugLightingMode());
-            Shader.SetGlobalVector("_DebugLightingAlbedo", debugAlbedo);
-            Shader.SetGlobalVector("_DebugLightingSmoothness", debugSmoothness);
+            Shader.SetGlobalInt(HDShaderIDs._DebugViewMaterial, (int)m_DebugDisplaySettings.GetDebugMaterialIndex());
+            Shader.SetGlobalInt(HDShaderIDs._DebugLightingMode, (int)m_DebugDisplaySettings.GetDebugLightingMode());
+            Shader.SetGlobalVector(HDShaderIDs._DebugLightingAlbedo, debugAlbedo);
+            Shader.SetGlobalVector(HDShaderIDs._DebugLightingSmoothness, debugSmoothness);
         }
 
         public void PushFullScreenDebugTexture(CommandBuffer cb, int textureID, Camera camera, ScriptableRenderContext renderContext, FullScreenDebugMode debugMode)
                 if(m_DebugDisplaySettings.lightingDebugSettings.fullScreenDebugMode != FullScreenDebugMode.None && m_FullScreenDebugPushed)
                 {
                     m_FullScreenDebugPushed = false;
-                    cmd.SetGlobalTexture("_DebugFullScreenTexture", m_DebugFullScreenTempRT);
-                    m_DebugFullScreen.SetFloat("_FullScreenDebugMode", (float)m_DebugDisplaySettings.lightingDebugSettings.fullScreenDebugMode);
+                    cmd.SetGlobalTexture(HDShaderIDs._DebugFullScreenTexture, m_DebugFullScreenTempRT);
+                    m_DebugFullScreen.SetFloat(HDShaderIDs._FullScreenDebugMode, (float)m_DebugDisplaySettings.lightingDebugSettings.fullScreenDebugMode);
                     Utilities.DrawFullScreen(cmd, m_DebugFullScreen, (RenderTargetIdentifier)BuiltinRenderTextureType.CameraTarget);
                 }
 
                 if (lightingDebug.displaySkyReflection)
                 {
                     Texture skyReflection = m_SkyManager.skyReflection;
-                    m_SharedPropertyBlock.SetTexture("_InputCubemap", skyReflection);
-                    m_SharedPropertyBlock.SetFloat("_Mipmap", lightingDebug.skyReflectionMipmap);
+                    m_SharedPropertyBlock.SetTexture(HDShaderIDs._InputCubemap, skyReflection);
+                    m_SharedPropertyBlock.SetFloat(HDShaderIDs._Mipmap, lightingDebug.skyReflectionMipmap);
                     cmd.SetViewport(new Rect(x, y, overlaySize, overlaySize));
                     cmd.DrawProcedural(Matrix4x4.identity, m_DebugDisplayLatlong, 0, MeshTopology.Triangles, 3, 1, m_SharedPropertyBlock);
                     Utilities.NextOverlayCoord(ref x, ref y, overlaySize, overlaySize, camera.camera.pixelWidth);
                     int w = camera.pixelWidth;
                     int h = camera.pixelHeight;
 
-                    cmd.GetTemporaryRT(m_CameraColorBuffer,             w, h,  0, FilterMode.Point, RenderTextureFormat.ARGBHalf,       RenderTextureReadWrite.Linear, 1, true); // Enable UAV
-                    cmd.GetTemporaryRT(m_CameraSubsurfaceBuffer,        w, h,  0, FilterMode.Point, RenderTextureFormat.RGB111110Float, RenderTextureReadWrite.Linear, 1, true); // Enable UAV
+                    cmd.GetTemporaryRT(m_CameraColorBuffer,             w, h, 0, FilterMode.Point, RenderTextureFormat.ARGBHalf,       RenderTextureReadWrite.Linear, 1, true); // Enable UAV
+                    cmd.GetTemporaryRT(m_CameraDiffuseIrradianceBuffer, w, h, 0, FilterMode.Point, RenderTextureFormat.RGB111110Float, RenderTextureReadWrite.Linear, 1, true); // Enable UAV
-                    cmd.GetTemporaryRT(m_CameraFilteringBuffer,         w, h,  0, FilterMode.Point, RenderTextureFormat.RGB111110Float, RenderTextureReadWrite.Linear, 1, true); // Enable UAV
+                    cmd.GetTemporaryRT(m_CameraFilteringBuffer,         w, h, 0, FilterMode.Point, RenderTextureFormat.RGB111110Float, RenderTextureReadWrite.Linear, 1, true); // Enable UAV
                     // <<< Old SSS Model
 
                     if (!m_Asset.renderingSettings.ShouldUseForwardRenderingOnly())
                 // Clear the diffuse SSS lighting target
                 using (new Utilities.ProfilingSample("Clear SSS diffuse target", cmd))
                 {
-                    Utilities.SetRenderTarget(cmd, m_CameraSubsurfaceBufferRT, m_CameraDepthStencilBufferRT, ClearFlag.ClearColor, Color.black);
+                    Utilities.SetRenderTarget(cmd, m_CameraDiffuseIrradianceBufferRT, m_CameraDepthStencilBufferRT, ClearFlag.ClearColor, Color.black);
-                // Clear the SSS filtering target
-                using (new Utilities.ProfilingSample("Clear SSS filtering target", cmd))
+                if (!sssSettings.useDisneySSS)
-                    Utilities.SetRenderTarget(cmd, m_CameraFilteringBuffer, m_CameraDepthStencilBufferRT, ClearFlag.ClearColor, Color.black);
+                    // Clear the SSS filtering target
+                    using (new Utilities.ProfilingSample("Clear SSS filtering target", cmd))
+                    {
+                        Utilities.SetRenderTarget(cmd, m_CameraFilteringBuffer, m_CameraDepthStencilBufferRT, ClearFlag.ClearColor, Color.black);
+                    }
+
+                if (NeedStencilBufferCopy())
+                {
+                    using (new Utilities.ProfilingSample("Clear stencil texture", cmd))
+                    {
+                        Utilities.SetRenderTarget(cmd, m_CameraStencilBufferCopyRT, ClearFlag.ClearColor, Color.black);
+                    }
+                }
+
+                if (NeedHTileCopy())
+                {
+                    using (new Utilities.ProfilingSample("Clear HTile", cmd))
+                    {
+                        Utilities.SetRenderTarget(cmd, m_HTileRT, ClearFlag.ClearColor, Color.black);
+                    }
+                }
 
                 // TEMP: As we are in development and have not all the setup pass we still clear the color in emissive buffer and gbuffer, but this will be removed later.
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipelineAsset.asset

     useForwardRenderingOnly: 0
     useDepthPrepass: 0
   sssSettings:
-    numProfiles: 4
+    numProfiles: 5
+    - {fileID: 11400000, guid: aa5f2cc1c22cad043a617e9e9548b1b9, type: 2}
+    texturingModeFlags: 0
+    transmissionFlags: 5120
+    thicknessRemaps:
+    - {x: 0, y: 12.031147, z: 0, w: 0}
+    - {x: 0, y: 5, z: 0, w: 0}
+    - {x: 0, y: 5, z: 0, w: 0}
+    - {x: 0, y: 12.031147, z: 0, w: 0}
+    - {x: 0, y: 12.031147, z: 0, w: 0}
+    - {x: 0, y: 0, z: 0, w: 0}
+    - {x: 0, y: 0, z: 0, w: 0}
+    - {x: 0, y: 0, z: 0, w: 0}
+    worldScales:
+    - {x: 1, y: 0, z: 0, w: 0}
+    - {x: 1, y: 0, z: 0, w: 0}
+    - {x: 1, y: 0, z: 0, w: 0}
+    - {x: 1, y: 0, z: 0, w: 0}
+    - {x: 1, y: 0, z: 0, w: 0}
+    - {x: 1, y: 1, z: 1, w: 1}
+    - {x: 1, y: 1, z: 1, w: 1}
+    - {x: 1, y: 1, z: 1, w: 1}
+    shapeParams:
+    - {x: 1.3192612, y: 3.1152647, z: 4.9751244, w: 10.03481}
+    - {x: 0.95712095, y: 2.5629592, z: 5.377674, w: 13.831622}
+    - {x: 0.95712095, y: 2.5629592, z: 5.377674, w: 13.831622}
+    - {x: 1.3192612, y: 3.1152647, z: 4.9751244, w: 10.03481}
+    - {x: 1.3192612, y: 3.1152647, z: 4.9751244, w: 10.03481}
+    - {x: 0, y: 0, z: 0, w: 0}
+    - {x: 0, y: 0, z: 0, w: 0}
+    - {x: 0, y: 0, z: 0, w: 0}
+    transmissionTints:
+    - {x: 0.7568628, y: 0.32156864, z: 0.20000002, w: 1}
+    - {x: 1, y: 1, z: 1, w: 1}
+    - {x: 1, y: 1, z: 1, w: 1}
+    - {x: 0.7568628, y: 0.32156864, z: 0.20000002, w: 1}
+    - {x: 0.7568628, y: 0.32156864, z: 0.20000002, w: 1}
+    - {x: 100, y: 0, z: 100, w: 1}
+    - {x: 100, y: 0, z: 100, w: 1}
+    - {x: 0, y: 0, z: 0, w: 0}
+    filterKernels:
+    - {x: 0.013865918, y: 1.5345725, z: 0.03667902, w: 1.5654991}
+    - {x: 0.04211352, y: 1.5729346, z: 0.11374626, w: 1.6734134}
+    - {x: 0.07107388, y: 1.6130018, z: 0.19626758, w: 1.7949444}
+    - {x: 0.100779116, y: 1.6548817, z: 0.28494877, w: 1.9325867}
+    - {x: 0.13126306, y: 1.6986896, z: 0.38062802, w: 2.0894418}
+    - {x: 0.16256203, y: 1.7445502, z: 0.48430943, w: 2.2694077}
+    - {x: 0.1947145, y: 1.7925992, z: 0.59720695, w: 2.4774427}
+    - {x: 0.22776169, y: 1.8429838, z: 0.72080237, w: 2.7199378}
+    - {x: 0.26174724, y: 1.8958628, z: 0.8569269, w: 3.005264}
+    - {x: 0.29671827, y: 1.9514104, z: 1.007873, w: 3.3445888}
+    - {x: 0.33272493, y: 2.0098157, z: 1.1765549, w: 3.7531407}
+    - {x: 0.369821, y: 2.0712852, z: 1.3667475, w: 4.252257}
+    - {x: 0.40806437, y: 2.1360447, z: 1.5834517, w: 4.872841}
+    - {x: 0.44751683, y: 2.2043417, z: 1.8334827, w: 5.6615734}
+    - {x: 0.48824534, y: 2.276447, z: 2.126473, w: 6.692844}
+    - {x: 0.5303216, y: 2.3526597, z: 2.4767098, w: 8.093767}
+    - {x: 0.5738235, y: 2.433308, z: 2.9068332, w: 10.102725}
+    - {x: 0.61883456, y: 2.5187542, z: 3.4562516, w: 13.228675}
+    - {x: 0.665446, y: 2.609401, z: 4.2041187, w: 18.793621}
+    - {x: 0.713756, y: 2.7056925, z: 5.3538504, w: 31.646347}
+    - {x: 0.763872, y: 2.808125, z: 7.84603, w: 95.44374}
+    - {x: 0.8159103, y: 2.91725, z: 0, w: 1}
+    - {x: 0.8699981, y: 3.0336854, z: 0, w: 1}
+    - {x: 0.9262747, y: 3.1581244, z: 0, w: 1}
+    - {x: 0.98489225, y: 3.2913465, z: 0, w: 1}
+    - {x: 1.0460185, y: 3.434234, z: 0, w: 1}
+    - {x: 1.1098381, y: 3.5877857, z: 0, w: 1}
+    - {x: 1.1765549, y: 3.7531407, z: 0, w: 1}
+    - {x: 1.2463952, y: 3.9316032, z: 0, w: 1}
+    - {x: 1.319611, y: 4.124672, z: 0, w: 1}
+    - {x: 1.3964823, y: 4.3340797, z: 0, w: 1}
+    - {x: 1.4773248, y: 4.561845, z: 0, w: 1}
+    - {x: 1.5624928, y: 4.810328, z: 0, w: 1}
+    - {x: 1.6523882, y: 5.082317, z: 0, w: 1}
+    - {x: 1.747467, y: 5.381122, z: 0, w: 1}
+    - {x: 1.8482518, y: 5.710715, z: 0, w: 1}
+    - {x: 1.9553448, y: 6.0759025, z: 0, w: 1}
+    - {x: 2.069445, y: 6.482568, z: 0, w: 1}
+    - {x: 2.1913698, y: 6.9379897, z: 0, w: 1}
+    - {x: 2.3220856, y: 7.4513016, z: 0, w: 1}
+    - {x: 2.4627466, y: 8.0341215, z: 0, w: 1}
+    - {x: 2.614747, y: 8.701484, z: 0, w: 1}
+    - {x: 2.7797952, y: 9.473195, z: 0, w: 1}
+    - {x: 2.9600194, y: 10.375936, z: 0, w: 1}
+    - {x: 3.1581159, y: 11.446505, z: 0, w: 1}
+    - {x: 3.3775842, y: 12.737201, z: 0, w: 1}
+    - {x: 3.6230793, y: 14.324919, z: 0, w: 1}
+    - {x: 3.9009922, y: 16.327562, z: 0, w: 1}
+    - {x: 4.220452, y: 18.935623, z: 0, w: 1}
+    - {x: 4.5951686, y: 22.478209, z: 0, w: 1}
+    - {x: 5.047148, y: 27.57712, z: 0, w: 1}
+    - {x: 5.615129, y: 35.564823, z: 0, w: 1}
+    - {x: 6.3776174, y: 49.90625, z: 0, w: 1}
+    - {x: 7.5374603, y: 83.30668, z: 0, w: 1}
+    - {x: 10.03481, y: 250.11497, z: 0, w: 1}
+    - {x: 0.019112285, y: 2.1151998, z: 0.05055704, w: 2.1578279}
+    - {x: 0.058047764, y: 2.1680765, z: 0.15678377, w: 2.306573}
+    - {x: 0.09796569, y: 2.223304, z: 0.27052817, w: 2.474087}
+    - {x: 0.13891032, y: 2.2810297, z: 0.3927631, w: 2.6638083}
+    - {x: 0.18092833, y: 2.3414128, z: 0.52464396, w: 2.8800118}
+    - {x: 0.22406968, y: 2.4046254, z: 0.6675549, w: 3.1280704}
+    - {x: 0.2683875, y: 2.4708545, z: 0.8231687, w: 3.4148183}
+    - {x: 0.31393853, y: 2.5403028, z: 0.9935282, w: 3.7490647}
+    - {x: 0.360783, y: 2.6131892, z: 1.1811574, w: 4.1423483}
+    - {x: 0.4089858, y: 2.689754, z: 1.3892161, w: 4.6100607}
+    - {x: 0.4586161, y: 2.7702577, z: 1.6217211, w: 5.1731944}
+    - {x: 0.50974804, y: 2.8549852, z: 1.8838758, w: 5.8611584}
+    - {x: 0.56246126, y: 2.9442472, z: 2.1825733, w: 6.71655}
+    - {x: 0.6168412, y: 3.0383852, z: 2.5272067, w: 7.8037086}
+    - {x: 0.67297983, y: 3.137773, z: 2.931054, w: 9.225176}
+    - {x: 0.73097634, y: 3.2428217, z: 3.413808, w: 11.1561575}
+    - {x: 0.79093766, y: 3.353984, z: 4.0066743, w: 13.925233}
+    - {x: 0.8529793, y: 3.4717607, z: 4.763973, w: 18.233932}
+    - {x: 0.917227, y: 3.5967052, z: 5.7948065, w: 25.904451}
+    - {x: 0.9838157, y: 3.7294297, z: 7.379556, w: 43.620197}
+    - {x: 1.0528938, y: 3.8706186, z: 10.814686, w: 131.55621}
+    - {x: 1.1246216, y: 4.0210333, z: 0, w: 1}
+    - {x: 1.1991742, y: 4.1815233, z: 0, w: 1}
+    - {x: 1.2767439, y: 4.3530455, z: 0, w: 1}
+    - {x: 1.3575401, y: 4.536674, z: 0, w: 1}
+    - {x: 1.4417944, y: 4.7336245, z: 0, w: 1}
+    - {x: 1.529761, y: 4.945275, z: 0, w: 1}
+    - {x: 1.6217211, y: 5.1731944, z: 0, w: 1}
+    - {x: 1.7179863, y: 5.4191804, z: 0, w: 1}
+    - {x: 1.8189045, y: 5.6853004, z: 0, w: 1}
+    - {x: 1.9248611, y: 5.97394, z: 0, w: 1}
+    - {x: 2.0362916, y: 6.287883, z: 0, w: 1}
+    - {x: 2.1536841, y: 6.6303835, z: 0, w: 1}
+    - {x: 2.277593, y: 7.0052843, z: 0, w: 1}
+    - {x: 2.4086456, y: 7.4171457, z: 0, w: 1}
+    - {x: 2.547564, y: 7.871444, z: 0, w: 1}
+    - {x: 2.6951776, y: 8.374806, z: 0, w: 1}
+    - {x: 2.8524487, y: 8.935339, z: 0, w: 1}
+    - {x: 3.0205052, y: 9.563076, z: 0, w: 1}
+    - {x: 3.2006793, y: 10.270607, z: 0, w: 1}
+    - {x: 3.3945613, y: 11.073945, z: 0, w: 1}
+    - {x: 3.6040735, y: 11.993813, z: 0, w: 1}
+    - {x: 3.8315694, y: 13.05751, z: 0, w: 1}
+    - {x: 4.0799847, y: 14.301818, z: 0, w: 1}
+    - {x: 4.353034, y: 15.777454, z: 0, w: 1}
+    - {x: 4.6555414, y: 17.556503, z: 0, w: 1}
+    - {x: 4.9939227, y: 19.744957, z: 0, w: 1}
+    - {x: 5.3769875, y: 22.505325, z: 0, w: 1}
+    - {x: 5.81732, y: 26.100191, z: 0, w: 1}
+    - {x: 6.333815, y: 30.983149, z: 0, w: 1}
+    - {x: 6.956808, y: 38.01131, z: 0, w: 1}
+    - {x: 7.739692, y: 49.02128, z: 0, w: 1}
+    - {x: 8.790676, y: 68.78892, z: 0, w: 1}
+    - {x: 10.389364, y: 114.826904, z: 0, w: 1}
+    - {x: 13.831622, y: 344.7495, z: 0, w: 1}
+    - {x: 0.019112285, y: 2.1151998, z: 0.05055704, w: 2.1578279}
+    - {x: 0.058047764, y: 2.1680765, z: 0.15678377, w: 2.306573}
+    - {x: 0.09796569, y: 2.223304, z: 0.27052817, w: 2.474087}
+    - {x: 0.13891032, y: 2.2810297, z: 0.3927631, w: 2.6638083}
+    - {x: 0.18092833, y: 2.3414128, z: 0.52464396, w: 2.8800118}
+    - {x: 0.22406968, y: 2.4046254, z: 0.6675549, w: 3.1280704}
+    - {x: 0.2683875, y: 2.4708545, z: 0.8231687, w: 3.4148183}
+    - {x: 0.31393853, y: 2.5403028, z: 0.9935282, w: 3.7490647}
+    - {x: 0.360783, y: 2.6131892, z: 1.1811574, w: 4.1423483}
+    - {x: 0.4089858, y: 2.689754, z: 1.3892161, w: 4.6100607}
+    - {x: 0.4586161, y: 2.7702577, z: 1.6217211, w: 5.1731944}
+    - {x: 0.50974804, y: 2.8549852, z: 1.8838758, w: 5.8611584}
+    - {x: 0.56246126, y: 2.9442472, z: 2.1825733, w: 6.71655}
+    - {x: 0.6168412, y: 3.0383852, z: 2.5272067, w: 7.8037086}
+    - {x: 0.67297983, y: 3.137773, z: 2.931054, w: 9.225176}
+    - {x: 0.73097634, y: 3.2428217, z: 3.413808, w: 11.1561575}
+    - {x: 0.79093766, y: 3.353984, z: 4.0066743, w: 13.925233}
+    - {x: 0.8529793, y: 3.4717607, z: 4.763973, w: 18.233932}
+    - {x: 0.917227, y: 3.5967052, z: 5.7948065, w: 25.904451}
+    - {x: 0.9838157, y: 3.7294297, z: 7.379556, w: 43.620197}
+    - {x: 1.0528938, y: 3.8706186, z: 10.814686, w: 131.55621}
+    - {x: 1.1246216, y: 4.0210333, z: 0, w: 1}
+    - {x: 1.1991742, y: 4.1815233, z: 0, w: 1}
+    - {x: 1.2767439, y: 4.3530455, z: 0, w: 1}
+    - {x: 1.3575401, y: 4.536674, z: 0, w: 1}
+    - {x: 1.4417944, y: 4.7336245, z: 0, w: 1}
+    - {x: 1.529761, y: 4.945275, z: 0, w: 1}
+    - {x: 1.6217211, y: 5.1731944, z: 0, w: 1}
+    - {x: 1.7179863, y: 5.4191804, z: 0, w: 1}
+    - {x: 1.8189045, y: 5.6853004, z: 0, w: 1}
+    - {x: 1.9248611, y: 5.97394, z: 0, w: 1}
+    - {x: 2.0362916, y: 6.287883, z: 0, w: 1}
+    - {x: 2.1536841, y: 6.6303835, z: 0, w: 1}
+    - {x: 2.277593, y: 7.0052843, z: 0, w: 1}
+    - {x: 2.4086456, y: 7.4171457, z: 0, w: 1}
+    - {x: 2.547564, y: 7.871444, z: 0, w: 1}
+    - {x: 2.6951776, y: 8.374806, z: 0, w: 1}
+    - {x: 2.8524487, y: 8.935339, z: 0, w: 1}
+    - {x: 3.0205052, y: 9.563076, z: 0, w: 1}
+    - {x: 3.2006793, y: 10.270607, z: 0, w: 1}
+    - {x: 3.3945613, y: 11.073945, z: 0, w: 1}
+    - {x: 3.6040735, y: 11.993813, z: 0, w: 1}
+    - {x: 3.8315694, y: 13.05751, z: 0, w: 1}
+    - {x: 4.0799847, y: 14.301818, z: 0, w: 1}
+    - {x: 4.353034, y: 15.777454, z: 0, w: 1}
+    - {x: 4.6555414, y: 17.556503, z: 0, w: 1}
+    - {x: 4.9939227, y: 19.744957, z: 0, w: 1}
+    - {x: 5.3769875, y: 22.505325, z: 0, w: 1}
+    - {x: 5.81732, y: 26.100191, z: 0, w: 1}
+    - {x: 6.333815, y: 30.983149, z: 0, w: 1}
+    - {x: 6.956808, y: 38.01131, z: 0, w: 1}
+    - {x: 7.739692, y: 49.02128, z: 0, w: 1}
+    - {x: 8.790676, y: 68.78892, z: 0, w: 1}
+    - {x: 10.389364, y: 114.826904, z: 0, w: 1}
+    - {x: 13.831622, y: 344.7495, z: 0, w: 1}
+    - {x: 0.013865918, y: 1.5345725, z: 0.03667902, w: 1.5654991}
+    - {x: 0.04211352, y: 1.5729346, z: 0.11374626, w: 1.6734134}
+    - {x: 0.07107388, y: 1.6130018, z: 0.19626758, w: 1.7949444}
+    - {x: 0.100779116, y: 1.6548817, z: 0.28494877, w: 1.9325867}
+    - {x: 0.13126306, y: 1.6986896, z: 0.38062802, w: 2.0894418}
+    - {x: 0.16256203, y: 1.7445502, z: 0.48430943, w: 2.2694077}
+    - {x: 0.1947145, y: 1.7925992, z: 0.59720695, w: 2.4774427}
+    - {x: 0.22776169, y: 1.8429838, z: 0.72080237, w: 2.7199378}
+    - {x: 0.26174724, y: 1.8958628, z: 0.8569269, w: 3.005264}
+    - {x: 0.29671827, y: 1.9514104, z: 1.007873, w: 3.3445888}
+    - {x: 0.33272493, y: 2.0098157, z: 1.1765549, w: 3.7531407}
+    - {x: 0.369821, y: 2.0712852, z: 1.3667475, w: 4.252257}
+    - {x: 0.40806437, y: 2.1360447, z: 1.5834517, w: 4.872841}
+    - {x: 0.44751683, y: 2.2043417, z: 1.8334827, w: 5.6615734}
+    - {x: 0.48824534, y: 2.276447, z: 2.126473, w: 6.692844}
+    - {x: 0.5303216, y: 2.3526597, z: 2.4767098, w: 8.093767}
+    - {x: 0.5738235, y: 2.433308, z: 2.9068332, w: 10.102725}
+    - {x: 0.61883456, y: 2.5187542, z: 3.4562516, w: 13.228675}
+    - {x: 0.665446, y: 2.609401, z: 4.2041187, w: 18.793621}
+    - {x: 0.713756, y: 2.7056925, z: 5.3538504, w: 31.646347}
+    - {x: 0.763872, y: 2.808125, z: 7.84603, w: 95.44374}
+    - {x: 0.8159103, y: 2.91725, z: 0, w: 1}
+    - {x: 0.8699981, y: 3.0336854, z: 0, w: 1}
+    - {x: 0.9262747, y: 3.1581244, z: 0, w: 1}
+    - {x: 0.98489225, y: 3.2913465, z: 0, w: 1}
+    - {x: 1.0460185, y: 3.434234, z: 0, w: 1}
+    - {x: 1.1098381, y: 3.5877857, z: 0, w: 1}
+    - {x: 1.1765549, y: 3.7531407, z: 0, w: 1}
+    - {x: 1.2463952, y: 3.9316032, z: 0, w: 1}
+    - {x: 1.319611, y: 4.124672, z: 0, w: 1}
+    - {x: 1.3964823, y: 4.3340797, z: 0, w: 1}
+    - {x: 1.4773248, y: 4.561845, z: 0, w: 1}
+    - {x: 1.5624928, y: 4.810328, z: 0, w: 1}
+    - {x: 1.6523882, y: 5.082317, z: 0, w: 1}
+    - {x: 1.747467, y: 5.381122, z: 0, w: 1}
+    - {x: 1.8482518, y: 5.710715, z: 0, w: 1}
+    - {x: 1.9553448, y: 6.0759025, z: 0, w: 1}
+    - {x: 2.069445, y: 6.482568, z: 0, w: 1}
+    - {x: 2.1913698, y: 6.9379897, z: 0, w: 1}
+    - {x: 2.3220856, y: 7.4513016, z: 0, w: 1}
+    - {x: 2.4627466, y: 8.0341215, z: 0, w: 1}
+    - {x: 2.614747, y: 8.701484, z: 0, w: 1}
+    - {x: 2.7797952, y: 9.473195, z: 0, w: 1}
+    - {x: 2.9600194, y: 10.375936, z: 0, w: 1}
+    - {x: 3.1581159, y: 11.446505, z: 0, w: 1}
+    - {x: 3.3775842, y: 12.737201, z: 0, w: 1}
+    - {x: 3.6230793, y: 14.324919, z: 0, w: 1}
+    - {x: 3.9009922, y: 16.327562, z: 0, w: 1}
+    - {x: 4.220452, y: 18.935623, z: 0, w: 1}
+    - {x: 4.5951686, y: 22.478209, z: 0, w: 1}
+    - {x: 5.047148, y: 27.57712, z: 0, w: 1}
+    - {x: 5.615129, y: 35.564823, z: 0, w: 1}
+    - {x: 6.3776174, y: 49.90625, z: 0, w: 1}
+    - {x: 7.5374603, y: 83.30668, z: 0, w: 1}
+    - {x: 10.03481, y: 250.11497, z: 0, w: 1}
+    - {x: 0.013865918, y: 1.5345725, z: 0.03667902, w: 1.5654991}
+    - {x: 0.04211352, y: 1.5729346, z: 0.11374626, w: 1.6734134}
+    - {x: 0.07107388, y: 1.6130018, z: 0.19626758, w: 1.7949444}
+    - {x: 0.100779116, y: 1.6548817, z: 0.28494877, w: 1.9325867}
+    - {x: 0.13126306, y: 1.6986896, z: 0.38062802, w: 2.0894418}
+    - {x: 0.16256203, y: 1.7445502, z: 0.48430943, w: 2.2694077}
+    - {x: 0.1947145, y: 1.7925992, z: 0.59720695, w: 2.4774427}
+    - {x: 0.22776169, y: 1.8429838, z: 0.72080237, w: 2.7199378}
+    - {x: 0.26174724, y: 1.8958628, z: 0.8569269, w: 3.005264}
+    - {x: 0.29671827, y: 1.9514104, z: 1.007873, w: 3.3445888}
+    - {x: 0.33272493, y: 2.0098157, z: 1.1765549, w: 3.7531407}
+    - {x: 0.369821, y: 2.0712852, z: 1.3667475, w: 4.252257}
+    - {x: 0.40806437, y: 2.1360447, z: 1.5834517, w: 4.872841}
+    - {x: 0.44751683, y: 2.2043417, z: 1.8334827, w: 5.6615734}
+    - {x: 0.48824534, y: 2.276447, z: 2.126473, w: 6.692844}
+    - {x: 0.5303216, y: 2.3526597, z: 2.4767098, w: 8.093767}
+    - {x: 0.5738235, y: 2.433308, z: 2.9068332, w: 10.102725}
+    - {x: 0.61883456, y: 2.5187542, z: 3.4562516, w: 13.228675}
+    - {x: 0.665446, y: 2.609401, z: 4.2041187, w: 18.793621}
+    - {x: 0.713756, y: 2.7056925, z: 5.3538504, w: 31.646347}
+    - {x: 0.763872, y: 2.808125, z: 7.84603, w: 95.44374}
+    - {x: 0.8159103, y: 2.91725, z: 0, w: 1}
+    - {x: 0.8699981, y: 3.0336854, z: 0, w: 1}
+    - {x: 0.9262747, y: 3.1581244, z: 0, w: 1}
+    - {x: 0.98489225, y: 3.2913465, z: 0, w: 1}
+    - {x: 1.0460185, y: 3.434234, z: 0, w: 1}
+    - {x: 1.1098381, y: 3.5877857, z: 0, w: 1}
+    - {x: 1.1765549, y: 3.7531407, z: 0, w: 1}
+    - {x: 1.2463952, y: 3.9316032, z: 0, w: 1}
+    - {x: 1.319611, y: 4.124672, z: 0, w: 1}
+    - {x: 1.3964823, y: 4.3340797, z: 0, w: 1}
+    - {x: 1.4773248, y: 4.561845, z: 0, w: 1}
+    - {x: 1.5624928, y: 4.810328, z: 0, w: 1}
+    - {x: 1.6523882, y: 5.082317, z: 0, w: 1}
+    - {x: 1.747467, y: 5.381122, z: 0, w: 1}
+    - {x: 1.8482518, y: 5.710715, z: 0, w: 1}
+    - {x: 1.9553448, y: 6.0759025, z: 0, w: 1}
+    - {x: 2.069445, y: 6.482568, z: 0, w: 1}
+    - {x: 2.1913698, y: 6.9379897, z: 0, w: 1}
+    - {x: 2.3220856, y: 7.4513016, z: 0, w: 1}
+    - {x: 2.4627466, y: 8.0341215, z: 0, w: 1}
+    - {x: 2.614747, y: 8.701484, z: 0, w: 1}
+    - {x: 2.7797952, y: 9.473195, z: 0, w: 1}
+    - {x: 2.9600194, y: 10.375936, z: 0, w: 1}
+    - {x: 3.1581159, y: 11.446505, z: 0, w: 1}
+    - {x: 3.3775842, y: 12.737201, z: 0, w: 1}
+    - {x: 3.6230793, y: 14.324919, z: 0, w: 1}
+    - {x: 3.9009922, y: 16.327562, z: 0, w: 1}
+    - {x: 4.220452, y: 18.935623, z: 0, w: 1}
+    - {x: 4.5951686, y: 22.478209, z: 0, w: 1}
+    - {x: 5.047148, y: 27.57712, z: 0, w: 1}
+    - {x: 5.615129, y: 35.564823, z: 0, w: 1}
+    - {x: 6.3776174, y: 49.90625, z: 0, w: 1}
+    - {x: 7.5374603, y: 83.30668, z: 0, w: 1}
+    - {x: 10.03481, y: 250.11497, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    - {x: 0, y: 1, z: 0, w: 1}
+    halfRcpWeightedVariances:
+    - {x: 2.4691355, y: 12.5, z: 12.5, w: 2.4691355}
+    - {x: 2, y: 2, z: 2, w: 2}
+    - {x: 2, y: 2, z: 2, w: 2}
+    - {x: 2.4691355, y: 12.5, z: 12.5, w: 2.4691355}
+    - {x: 2.4691355, y: 12.5, z: 12.5, w: 2.4691355}
+    - {x: 1, y: 1, z: 1, w: 1}
+    - {x: 1, y: 1, z: 1, w: 1}
+    - {x: 1, y: 1, z: 1, w: 1}
+    filterKernelsBasic:
+    - {x: 0.09090909, y: 0.21162307, z: 0.21162307, w: -0.000000048879357}
+    - {x: 0.09090909, y: 0.18990478, z: 0.18990478, w: -0.11381993}
+    - {x: 0.09090909, y: 0.13233659, z: 0.13233659, w: -0.23580086}
+    - {x: 0.09090909, y: 0.061445467, z: 0.061445467, w: -0.37865555}
+    - {x: 0.09090909, y: 0.010501689, z: 0.010501689, w: -0.57677805}
+    - {x: 0.09090909, y: 2.9458339e-10, z: 2.9458339e-10, w: -1.3907351}
+    - {x: 0.09090909, y: 0.18990476, z: 0.18990476, w: 0.11382001}
+    - {x: 0.09090909, y: 0.13233659, z: 0.13233659, w: 0.23580086}
+    - {x: 0.09090909, y: 0.061445467, z: 0.061445467, w: 0.37865555}
+    - {x: 0.09090909, y: 0.010501689, z: 0.010501689, w: 0.57677805}
+    - {x: 0.09090909, y: 2.9456845e-10, z: 2.9456845e-10, w: 1.3907368}
+    - {x: 0.09090909, y: 0.09090909, z: 0.09090909, w: -0.000000054310398}
+    - {x: 0.09090909, y: 0.09090909, z: 0.09090909, w: -0.12646659}
+    - {x: 0.09090909, y: 0.09090909, z: 0.09090909, w: -0.26200095}
+    - {x: 0.09090909, y: 0.09090909, z: 0.09090909, w: -0.42072836}
+    - {x: 0.09090909, y: 0.09090909, z: 0.09090909, w: -0.64086443}
+    - {x: 0.09090909, y: 0.09090909, z: 0.09090909, w: -1.5452611}
+    - {x: 0.09090909, y: 0.09090909, z: 0.09090909, w: 0.12646668}
+    - {x: 0.09090909, y: 0.09090909, z: 0.09090909, w: 0.26200095}
+    - {x: 0.09090909, y: 0.09090909, z: 0.09090909, w: 0.42072836}
+    - {x: 0.09090909, y: 0.09090909, z: 0.09090909, w: 0.64086443}
+    - {x: 0.09090909, y: 0.09090909, z: 0.09090909, w: 1.545263}
+    - {x: 0.09090909, y: 0.09090909, z: 0.09090909, w: -0.000000054310398}
+    - {x: 0.09090909, y: 0.09090909, z: 0.09090909, w: -0.12646659}
+    - {x: 0.09090909, y: 0.09090909, z: 0.09090909, w: -0.26200095}
+    - {x: 0.09090909, y: 0.09090909, z: 0.09090909, w: -0.42072836}
+    - {x: 0.09090909, y: 0.09090909, z: 0.09090909, w: -0.64086443}
+    - {x: 0.09090909, y: 0.09090909, z: 0.09090909, w: -1.5452611}
+    - {x: 0.09090909, y: 0.09090909, z: 0.09090909, w: 0.12646668}
+    - {x: 0.09090909, y: 0.09090909, z: 0.09090909, w: 0.26200095}
+    - {x: 0.09090909, y: 0.09090909, z: 0.09090909, w: 0.42072836}
+    - {x: 0.09090909, y: 0.09090909, z: 0.09090909, w: 0.64086443}
+    - {x: 0.09090909, y: 0.09090909, z: 0.09090909, w: 1.545263}
+    - {x: 0.09090909, y: 0.21162307, z: 0.21162307, w: -0.000000048879357}
+    - {x: 0.09090909, y: 0.18990478, z: 0.18990478, w: -0.11381993}
+    - {x: 0.09090909, y: 0.13233659, z: 0.13233659, w: -0.23580086}
+    - {x: 0.09090909, y: 0.061445467, z: 0.061445467, w: -0.37865555}
+    - {x: 0.09090909, y: 0.010501689, z: 0.010501689, w: -0.57677805}
+    - {x: 0.09090909, y: 2.9458339e-10, z: 2.9458339e-10, w: -1.3907351}
+    - {x: 0.09090909, y: 0.18990476, z: 0.18990476, w: 0.11382001}
+    - {x: 0.09090909, y: 0.13233659, z: 0.13233659, w: 0.23580086}
+    - {x: 0.09090909, y: 0.061445467, z: 0.061445467, w: 0.37865555}
+    - {x: 0.09090909, y: 0.010501689, z: 0.010501689, w: 0.57677805}
+    - {x: 0.09090909, y: 2.9456845e-10, z: 2.9456845e-10, w: 1.3907368}
+    - {x: 0.09090909, y: 0.21162307, z: 0.21162307, w: -0.000000048879357}
+    - {x: 0.09090909, y: 0.18990478, z: 0.18990478, w: -0.11381993}
+    - {x: 0.09090909, y: 0.13233659, z: 0.13233659, w: -0.23580086}
+    - {x: 0.09090909, y: 0.061445467, z: 0.061445467, w: -0.37865555}
+    - {x: 0.09090909, y: 0.010501689, z: 0.010501689, w: -0.57677805}
+    - {x: 0.09090909, y: 2.9458339e-10, z: 2.9458339e-10, w: -1.3907351}
+    - {x: 0.09090909, y: 0.18990476, z: 0.18990476, w: 0.11382001}
+    - {x: 0.09090909, y: 0.13233659, z: 0.13233659, w: 0.23580086}
+    - {x: 0.09090909, y: 0.061445467, z: 0.061445467, w: 0.37865555}
+    - {x: 0.09090909, y: 0.010501689, z: 0.010501689, w: 0.57677805}
+    - {x: 0.09090909, y: 2.9456845e-10, z: 2.9456845e-10, w: 1.3907368}
+    - {x: 1, y: 1, z: 1, w: 0}
+    - {x: 1, y: 1, z: 1, w: 0}
+    - {x: 1, y: 1, z: 1, w: 0}
+    - {x: 1, y: 1, z: 1, w: 0}
+    - {x: 1, y: 1, z: 1, w: 0}
+    - {x: 1, y: 1, z: 1, w: 0}
+    - {x: 1, y: 1, z: 1, w: 0}
+    - {x: 1, y: 1, z: 1, w: 0}
+    - {x: 1, y: 1, z: 1, w: 0}
+    - {x: 1, y: 1, z: 1, w: 0}
+    - {x: 1, y: 1, z: 1, w: 0}
+    - {x: 1, y: 1, z: 1, w: 0}
+    - {x: 1, y: 1, z: 1, w: 0}
+    - {x: 1, y: 1, z: 1, w: 0}
+    - {x: 1, y: 1, z: 1, w: 0}
+    - {x: 1, y: 1, z: 1, w: 0}
+    - {x: 1, y: 1, z: 1, w: 0}
+    - {x: 1, y: 1, z: 1, w: 0}
+    - {x: 1, y: 1, z: 1, w: 0}
+    - {x: 1, y: 1, z: 1, w: 0}
+    - {x: 1, y: 1, z: 1, w: 0}
+    - {x: 1, y: 1, z: 1, w: 0}
+    - {x: 1, y: 1, z: 1, w: 0}
+    - {x: 1, y: 1, z: 1, w: 0}
+    - {x: 1, y: 1, z: 1, w: 0}
+    - {x: 1, y: 1, z: 1, w: 0}
+    - {x: 1, y: 1, z: 1, w: 0}
+    - {x: 1, y: 1, z: 1, w: 0}
+    - {x: 1, y: 1, z: 1, w: 0}
+    - {x: 1, y: 1, z: 1, w: 0}
+    - {x: 1, y: 1, z: 1, w: 0}
+    - {x: 1, y: 1, z: 1, w: 0}
+    - {x: 1, y: 1, z: 1, w: 0}
-    enableSplitLightEvaluation: 1
     enableComputeLightEvaluation: 1
     enableComputeLightVariants: 1
     enableComputeMaterialVariants: 1

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/AmbientOcclusion/ScreenSpaceAmbientOcclusion.cs

             internal static readonly int _Downsample = Shader.PropertyToID("_Downsample");
             internal static readonly int _SampleCount = Shader.PropertyToID("_SampleCount");
             internal static readonly int _MainTex = Shader.PropertyToID("_MainTex");
-            internal static readonly int _AOBuffer = Shader.PropertyToID("_AmbientOcclusionTexture");
             internal static readonly int _TempTex1 = Shader.PropertyToID("_TempTex1");
             internal static readonly int _TempTex2 = Shader.PropertyToID("_TempTex2");
         }
             // If SSAO is disable, simply put a white 1x1 texture
             if (settings.enable == false || isForward)
             {
-                cmd.SetGlobalTexture(Uniforms._AOBuffer, UnityEngine.Rendering.PostProcessing.RuntimeUtilities.blackTexture); // Neutral is black, see the comment in the shaders
+                cmd.SetGlobalTexture(HDShaderIDs._AmbientOcclusionTexture, UnityEngine.Rendering.PostProcessing.RuntimeUtilities.blackTexture); // Neutral is black, see the comment in the shaders
+                cmd.SetGlobalFloat(HDShaderIDs._AmbientOcclusionDirectLightStrenght, 0.0f);
                 return;
             }
 
                 cmd.ReleaseTemporaryRT(Uniforms._TempTex2);
 
                 // Final filtering
-                cmd.GetTemporaryRT(Uniforms._AOBuffer, width, height, 0, kFilter, GetAOBufferFormat(), kRWMode);
+                cmd.GetTemporaryRT(HDShaderIDs._AmbientOcclusionTexture, width, height, 0, kFilter, GetAOBufferFormat(), kRWMode);
-                Utilities.DrawFullScreen(cmd, m_Material, Uniforms._AOBuffer, null, 3);
+                Utilities.DrawFullScreen(cmd, m_Material, HDShaderIDs._AmbientOcclusionTexture, null, 3);
-                // Setup texture for lighting pass (automagic of unity)
-                cmd.SetGlobalTexture("_AmbientOcclusionTexture", Uniforms._AOBuffer);
-                hdRP.PushFullScreenDebugTexture(cmd, Uniforms._AOBuffer, hdCamera.camera, renderContext, FullScreenDebugMode.SSAO);
+                // Setup texture for lighting pass (automatic of unity)
+                cmd.SetGlobalTexture(HDShaderIDs._AmbientOcclusionTexture, HDShaderIDs._AmbientOcclusionTexture);
+                cmd.SetGlobalFloat(HDShaderIDs._AmbientOcclusionDirectLightStrenght, settings.affectDirectLigthingStrenght);
+                hdRP.PushFullScreenDebugTexture(cmd, HDShaderIDs._AmbientOcclusionTexture, hdCamera.camera, renderContext, FullScreenDebugMode.SSAO);
             }
         }
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/AmbientOcclusion/ScreenSpaceAmbientOcclusion.shader

     HLSLINCLUDE
 
     #include "../../../ShaderLibrary/Common.hlsl"
-    #include "../../ShaderConfig.cs.hlsl"
     #include "../../ShaderVariables.hlsl"
 
     #define UNITY_MATERIAL_LIT // Needs to be defined before including Material.hlsl

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/AmbientOcclusion/ScreenSpaceAmbientOcclusionSettings.cs

             [SerializeField]
             bool m_Enable;
 
+            [SerializeField, Range(0, 1)]
+            float m_AffectDirectLigthingStrenght;
+
             [SerializeField, Range(0, 2)]
             float m_Intensity;
             [SerializeField]
             bool m_Downsampling;
 
             public bool enable { set { m_Enable = value; } get { return m_Enable; } }
+            public float affectDirectLigthingStrenght { set { m_AffectDirectLigthingStrenght = value; OnValidate(); } get { return m_AffectDirectLigthingStrenght; } }
             public float intensity { set { m_Intensity = value; OnValidate(); } get { return m_Intensity; } }
             public float radius { set { m_Radius = value; OnValidate(); } get { return m_Radius; } }
             public int sampleCount { set { m_SampleCount = value; OnValidate(); } get { return m_SampleCount; } }
             {
+                m_AffectDirectLigthingStrenght = Mathf.Clamp(m_AffectDirectLigthingStrenght, 0, 1);
                 m_Intensity = Mathf.Clamp(m_Intensity, 0, 2);
                 m_Radius = Mathf.Max(0, m_Radius);
                 m_SampleCount = Mathf.Clamp(m_SampleCount, 1, 32);
             {
                 m_Enable = false,
+                m_AffectDirectLigthingStrenght = 0.0f,
                 m_Intensity = 1.0f,
                 m_Radius = 0.5f,
                 m_SampleCount = 8,

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/Deferred.shader

 
             // Chose supported lighting architecture in case of deferred rendering
             #pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS
-
-            // TODO: Workflow problem here, I would like to only generate variant for the LIGHTLOOP_TILE_PASS case, not the LIGHTLOOP_SINGLE_PASS case. This must be on lightloop side and include here.... (Can we codition
-            #pragma multi_compile LIGHTLOOP_TILE_DIRECT LIGHTLOOP_TILE_INDIRECT LIGHTLOOP_TILE_ALL
             #pragma multi_compile USE_FPTL_LIGHTLIST USE_CLUSTERED_LIGHTLIST
 
             // Split lighting is utilized during the SSS pass.
             // deferred material must replace the old one here. If in the future we want to support multiple layout (cause a lot of consistency problem),
             // the deferred shader will require to use multicompile.
             #define UNITY_MATERIAL_LIT // Need to be define before including Material.hlsl
-            #include "../ShaderConfig.cs.hlsl"
             #include "../ShaderVariables.hlsl"
             #include "../Lighting/Lighting.hlsl" // This include Material.hlsl
 
 
             Outputs Frag(Varyings input)
             {
+                // This need to stay in sync with deferred.compute
+
                 // input.positionCS is SV_Position
                 PositionInputs posInput = GetPositionInput(input.positionCS.xy, _ScreenSize.zw, uint2(input.positionCS.xy) / GetTileSize());
                 float depth = LOAD_TEXTURE2D(_MainDepthTexture, posInput.unPositionSS).x;
             #ifdef OUTPUT_SPLIT_LIGHTING
                 outputs.specularLighting = float4(specularLighting, 1.0);
                 outputs.diffuseLighting  = diffuseLighting;
-                #if defined(LIGHTLOOP_TILE_INDIRECT) || defined(LIGHTLOOP_TILE_ALL)
-                    // We SSSSS is enabled with use split lighting.
-                    // SSSSS algorithm need to know which pixels contribute to SSS and which doesn't. We could use the stencil for that but it mean that it will increase the cost of SSSSS
-                    // A simpler solution is to add a slight contribution here that isn't visible (here we chose fp16 min (which is also fp11 and fp10 min).
-                    // The SSSSS algorithm will check if diffuse lighting is black and discard the pixel if it is the case
-                    outputs.diffuseLighting.r = max(outputs.diffuseLighting.r, HFLT_MIN);
-                #endif
+                // We SSSSS is enabled with use split lighting.
+                // SSSSS algorithm need to know which pixels contribute to SSS and which doesn't. We could use the stencil for that but it mean that it will increase the cost of SSSSS
+                // A simpler solution is to add a slight contribution here that isn't visible (here we chose fp16 min (which is also fp11 and fp10 min).
+                // The SSSSS algorithm will check if diffuse lighting is black and discard the pixel if it is the case
+                outputs.diffuseLighting.r = max(outputs.diffuseLighting.r, HFLT_MIN);
             #else
                 outputs.combinedLighting = float4(diffuseLighting + specularLighting, 1.0);
             #endif

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/Forward.hlsl

 
 // No USE_FPTL_LIGHTLIST as we are in forward and this use the cluster path (but cluster path can use the tile light list for opaque)
 #define USE_CLUSTERED_LIGHTLIST
-#define LIGHTLOOP_TILE_ALL

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/ShadowDispatch.hlsl

 	SamplerComparisonState	compSamp = shadowContext.compSamplers[SHADOW_DISPATCH_DIR_SMP];
 	uint			        algo     = SHADOW_DISPATCH_DIR_ALG;
 
-	return EvalShadow_CascadedDepth( shadowContext, algo, tex, compSamp, positionWS, normalWS, shadowDataIndex, L );
+	return EvalShadow_CascadedDepth_Blend( shadowContext, algo, tex, compSamp, positionWS, normalWS, shadowDataIndex, L );
 }
 
 float GetDirectionalShadowAttenuation( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float3 L, float2 unPositionSS )

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/TilePass.cs

                     if(computeShader)
                     {
                         // bind buffers
-                        cb.SetComputeBufferParam(computeShader, computeKernel, "_ShadowDatasExp", s_ShadowDataBuffer);
-                        cb.SetComputeBufferParam(computeShader, computeKernel, "_ShadowPayloads", s_ShadowPayloadBuffer);
+                        cb.SetComputeBufferParam(computeShader, computeKernel, HDShaderIDs._ShadowDatasExp, s_ShadowDataBuffer);
+                        cb.SetComputeBufferParam(computeShader, computeKernel, HDShaderIDs._ShadowPayloads, s_ShadowPayloadBuffer);
-                        cb.SetComputeTextureParam(computeShader, computeKernel, "_ShadowmapExp_VSM_0", tex[0]);
-                        cb.SetComputeTextureParam(computeShader, computeKernel, "_ShadowmapExp_VSM_1", tex[1]);
-                        cb.SetComputeTextureParam(computeShader, computeKernel, "_ShadowmapExp_VSM_2", tex[2]);
-                        cb.SetComputeTextureParam(computeShader, computeKernel, "_ShadowmapExp_PCF", tex[3]);
+                        cb.SetComputeTextureParam(computeShader, computeKernel, HDShaderIDs._ShadowmapExp_VSM_0, tex[0]);
+                        cb.SetComputeTextureParam(computeShader, computeKernel, HDShaderIDs._ShadowmapExp_VSM_1, tex[1]);
+                        cb.SetComputeTextureParam(computeShader, computeKernel, HDShaderIDs._ShadowmapExp_VSM_2, tex[2]);
+                        cb.SetComputeTextureParam(computeShader, computeKernel, HDShaderIDs._ShadowmapExp_PCF, tex[3]);
-                        cb.SetGlobalBuffer("_ShadowDatasExp", s_ShadowDataBuffer);
-                        cb.SetGlobalBuffer("_ShadowPayloads", s_ShadowPayloadBuffer);
+                        cb.SetGlobalBuffer(HDShaderIDs._ShadowDatasExp, s_ShadowDataBuffer);
+                        cb.SetGlobalBuffer(HDShaderIDs._ShadowPayloads, s_ShadowPayloadBuffer);
-                        cb.SetGlobalTexture("_ShadowmapExp_VSM_0", tex[0]);
-                        cb.SetGlobalTexture("_ShadowmapExp_VSM_1", tex[1]);
-                        cb.SetGlobalTexture("_ShadowmapExp_VSM_2", tex[2]);
-                        cb.SetGlobalTexture("_ShadowmapExp_PCF", tex[3]);
+                        cb.SetGlobalTexture(HDShaderIDs._ShadowmapExp_VSM_0, tex[0]);
+                        cb.SetGlobalTexture(HDShaderIDs._ShadowmapExp_VSM_1, tex[1]);
+                        cb.SetGlobalTexture(HDShaderIDs._ShadowmapExp_VSM_2, tex[2]);
+                        cb.SetGlobalTexture(HDShaderIDs._ShadowmapExp_PCF, tex[3]);
                     }
 
                     // TODO: Currently samplers are hard coded in ShadowContext.hlsl, so we can't really set them here
             public static int s_TileSizeClustered = 32;
 
             // feature variants
-            public static int s_NumFeatureVariants = 26;
+            public static int s_NumFeatureVariants = 31;
 
             // Following define the maximum number of bits use in each feature category.
             public static uint s_LightFeatureMaskFlags = 0xFF00;
             private ComputeShader buildMaterialFlagsShader { get { return m_Resources.buildMaterialFlagsShader; } }
             private ComputeShader buildDispatchIndirectShader { get { return m_Resources.buildDispatchIndirectShader; } }
             private ComputeShader clearDispatchIndirectShader { get { return m_Resources.clearDispatchIndirectShader; } }
-            private ComputeShader shadeOpaqueShader { get { return m_Resources.shadeOpaqueShader; } }
+            private ComputeShader deferredComputeShader { get { return m_Resources.deferredComputeShader; } }
 
             static int s_GenAABBKernel;
             static int s_GenListPerTileKernel;
             static int s_shadeOpaqueDirectFptlKernel;
             static int s_shadeOpaqueDirectClusteredDebugDisplayKernel;
             static int s_shadeOpaqueDirectFptlDebugDisplayKernel;
-            static int[] s_shadeOpaqueIndirectClusteredKernels = new int[LightDefinitions.s_NumFeatureVariants];
+            // Tag: SUPPORT_COMPUTE_CLUSTER_OPAQUE - Uncomment this if you want to do cluster opaque with compute shader (by default we support only fptl on opaque)
+            //static int[] s_shadeOpaqueIndirectClusteredKernels = new int[LightDefinitions.s_NumFeatureVariants];
             static int[] s_shadeOpaqueIndirectFptlKernels = new int[LightDefinitions.s_NumFeatureVariants];
 
             static ComputeBuffer s_LightVolumeDataBuffer = null;
                 return (camera.pixelHeight + (LightDefinitions.s_TileSizeClustered - 1)) / LightDefinitions.s_TileSizeClustered;
             }
 
-            bool GetFeatureVariantsEnabled()
+            public static bool GetFeatureVariantsEnabled(TileSettings tileSettings)
-                return m_TileSettings.enableComputeLightEvaluation && (m_TileSettings.enableComputeLightVariants || m_TileSettings.enableComputeMaterialVariants) && !(m_TileSettings.enableClustered && !m_TileSettings.enableFptlForOpaqueWhenClustered);
+                return tileSettings.enableComputeLightEvaluation && (tileSettings.enableComputeLightVariants || tileSettings.enableComputeMaterialVariants) && !(tileSettings.enableClustered && !tileSettings.enableFptlForOpaqueWhenClustered);
             }
 
             TileSettings m_TileSettings = null;
 
                 s_GenAABBKernel = buildScreenAABBShader.FindKernel("ScreenBoundsAABB");
 
-                bool enableFeatureVariants = GetFeatureVariantsEnabled();
+                bool enableFeatureVariants = GetFeatureVariantsEnabled(m_TileSettings);
                 if (enableFeatureVariants)
                 {
                     s_GenListPerTileKernel = buildPerTileLightListShader.FindKernel(m_TileSettings.enableBigTilePrepass ? "TileLightListGen_SrcBigTile_FeatureFlags" : "TileLightListGen_FeatureFlags");
                 s_BuildMaterialFlagsOrKernel = buildMaterialFlagsShader.FindKernel("MaterialFlagsGen_Or");
                 s_BuildMaterialFlagsWriteKernel = buildMaterialFlagsShader.FindKernel("MaterialFlagsGen_Write");
 
-                s_shadeOpaqueDirectClusteredKernel = shadeOpaqueShader.FindKernel("ShadeOpaque_Direct_Clustered");
-                s_shadeOpaqueDirectFptlKernel = shadeOpaqueShader.FindKernel("ShadeOpaque_Direct_Fptl");
-                s_shadeOpaqueDirectClusteredDebugDisplayKernel = shadeOpaqueShader.FindKernel("ShadeOpaque_Direct_Clustered_DebugDisplay");
-                s_shadeOpaqueDirectFptlDebugDisplayKernel = shadeOpaqueShader.FindKernel("ShadeOpaque_Direct_Fptl_DebugDisplay");
+                s_shadeOpaqueDirectClusteredKernel = deferredComputeShader.FindKernel("Deferred_Direct_Clustered");
+                s_shadeOpaqueDirectFptlKernel = deferredComputeShader.FindKernel("Deferred_Direct_Fptl");
+                s_shadeOpaqueDirectClusteredDebugDisplayKernel = deferredComputeShader.FindKernel("Deferred_Direct_Clustered_DebugDisplay");
+                s_shadeOpaqueDirectFptlDebugDisplayKernel = deferredComputeShader.FindKernel("Deferred_Direct_Fptl_DebugDisplay");
-                    s_shadeOpaqueIndirectClusteredKernels[variant] = shadeOpaqueShader.FindKernel("ShadeOpaque_Indirect_Clustered_Variant" + variant);
-                    s_shadeOpaqueIndirectFptlKernels[variant] = shadeOpaqueShader.FindKernel("ShadeOpaque_Indirect_Fptl_Variant" + variant);
+                    // Tag: SUPPORT_CLUSTER_OPAQUE - Uncomment this if you want to do cluster opaque (by default we support only fptl on opaque)
+                    // s_shadeOpaqueIndirectClusteredKernels[variant] = deferredComputeShader.FindKernel("Deferred_Indirect_Clustered_Variant" + variant);
+                    s_shadeOpaqueIndirectFptlKernels[variant] = deferredComputeShader.FindKernel("Deferred_Indirect_Fptl_Variant" + variant);
-
-                string[] tileKeywords = {"LIGHTLOOP_TILE_DIRECT", "LIGHTLOOP_TILE_INDIRECT", "LIGHTLOOP_TILE_ALL"};
-                Utilities.SelectKeyword(m_DeferredAllMaterialSRT, tileKeywords, 2);
-                m_DeferredAllMaterialSRT.SetInt("_StencilRef", (int)StencilLightingUsage.RegularLighting);
-                m_DeferredAllMaterialSRT.SetInt("_StencilCmp", (int)CompareFunction.Equal);
-                m_DeferredAllMaterialSRT.SetInt("_SrcBlend", (int)BlendMode.One);
-                m_DeferredAllMaterialSRT.SetInt("_DstBlend", (int)BlendMode.Zero);
+                m_DeferredAllMaterialSRT.SetInt(HDShaderIDs._StencilRef, (int)StencilLightingUsage.RegularLighting);
+                m_DeferredAllMaterialSRT.SetInt(HDShaderIDs._StencilCmp, (int)CompareFunction.Equal);
+                m_DeferredAllMaterialSRT.SetInt(HDShaderIDs._SrcBlend, (int)BlendMode.One);
+                m_DeferredAllMaterialSRT.SetInt(HDShaderIDs._DstBlend, (int)BlendMode.Zero);
-                Utilities.SelectKeyword(m_DeferredAllMaterialMRT, tileKeywords, 2);
-                m_DeferredAllMaterialMRT.SetInt("_StencilRef", (int)StencilLightingUsage.SplitLighting);
-                m_DeferredAllMaterialMRT.SetInt("_StencilCmp", (int)CompareFunction.Equal);
-                m_DeferredAllMaterialMRT.SetInt("_SrcBlend", (int)BlendMode.One);
-                m_DeferredAllMaterialMRT.SetInt("_DstBlend", (int)BlendMode.Zero);
+                m_DeferredAllMaterialMRT.SetInt(HDShaderIDs._StencilRef, (int)StencilLightingUsage.SplitLighting);
+                m_DeferredAllMaterialMRT.SetInt(HDShaderIDs._StencilCmp, (int)CompareFunction.Equal);
+                m_DeferredAllMaterialMRT.SetInt(HDShaderIDs._SrcBlend, (int)BlendMode.One);
+                m_DeferredAllMaterialMRT.SetInt(HDShaderIDs._DstBlend, (int)BlendMode.Zero);
-                m_SingleDeferredMaterialSRT.SetInt("_StencilRef", (int)StencilLightingUsage.RegularLighting);
-                m_SingleDeferredMaterialSRT.SetInt("_StencilCmp", (int)CompareFunction.Equal);
-                m_SingleDeferredMaterialSRT.SetInt("_SrcBlend", (int)BlendMode.One);
-                m_SingleDeferredMaterialSRT.SetInt("_DstBlend", (int)BlendMode.Zero);
+                m_SingleDeferredMaterialSRT.SetInt(HDShaderIDs._StencilRef, (int)StencilLightingUsage.RegularLighting);
+                m_SingleDeferredMaterialSRT.SetInt(HDShaderIDs._StencilCmp, (int)CompareFunction.Equal);
+                m_SingleDeferredMaterialSRT.SetInt(HDShaderIDs._SrcBlend, (int)BlendMode.One);
+                m_SingleDeferredMaterialSRT.SetInt(HDShaderIDs._DstBlend, (int)BlendMode.Zero);
-                m_SingleDeferredMaterialMRT.SetInt("_StencilRef", (int)StencilLightingUsage.SplitLighting);
-                m_SingleDeferredMaterialMRT.SetInt("_StencilCmp", (int)CompareFunction.Equal);
-                m_SingleDeferredMaterialMRT.SetInt("_SrcBlend", (int)BlendMode.One);
-                m_SingleDeferredMaterialMRT.SetInt("_DstBlend", (int)BlendMode.Zero);
+                m_SingleDeferredMaterialMRT.SetInt(HDShaderIDs._StencilRef, (int)StencilLightingUsage.SplitLighting);
+                m_SingleDeferredMaterialMRT.SetInt(HDShaderIDs._StencilCmp, (int)CompareFunction.Equal);
+                m_SingleDeferredMaterialMRT.SetInt(HDShaderIDs._SrcBlend, (int)BlendMode.One);
+                m_SingleDeferredMaterialMRT.SetInt(HDShaderIDs._DstBlend, (int)BlendMode.Zero);
 
                 m_DebugViewTilesMaterial = Utilities.CreateEngineMaterial(m_Resources.debugViewTilesShader);
 
 
                     for (int probeIndex = 0, numProbes = cullResults.visibleReflectionProbes.Count; (probeIndex < numProbes) && (sortCount < probeCount); probeIndex++)
                     {
-                        var probe = cullResults.visibleReflectionProbes[probeIndex];
+                        VisibleReflectionProbe probe = cullResults.visibleReflectionProbes[probeIndex];
 
                         // probe.texture can be null when we are adding a reflection probe in the editor
                         if (probe.texture == null || envLightCount >= k_MaxEnvLightsOnScreen)
                         LightVolumeType lightVolumeType = probe.boxProjection != 0 ? LightVolumeType.Box : LightVolumeType.Box;
                         ++envLightCount;
 
-                        // 16 bit lightVolume, 16 bit index
-                        sortKeys[sortCount++] = (uint)lightVolumeType << 16 | (uint)probeIndex;
+                        float boxVolume = 8 * probe.bounds.extents.x * probe.bounds.extents.y * probe.bounds.extents.z;
+                        float logVolume = Mathf.Clamp(256 + Mathf.Log(boxVolume, 1.1f), 0, 8191); // Allow for negative exponents
+
+                        // 13 bit volume, 3 bit LightVolumeType, 16 bit index
+                        sortKeys[sortCount++] = (uint)logVolume << 19 | (uint)lightVolumeType << 16 | ((uint)probeIndex & 0xFFFF); // Sort by volume
                     }
 
                     // Not necessary yet but call it for future modification with sphere influence volume
                     {
                         // In 1. we have already classify and sorted the light, we need to use this sorted order here
                         uint sortKey = sortKeys[sortIndex];
-                        LightVolumeType lightVolumeType = (LightVolumeType)((sortKey >> 16) & 0xFFFF);
+                        LightVolumeType lightVolumeType = (LightVolumeType)((sortKey >> 16) & 0x3);
                         int probeIndex = (int)(sortKey & 0xFFFF);
 
                         VisibleReflectionProbe probe = cullResults.visibleReflectionProbes[probeIndex];
             void VoxelLightListGeneration(CommandBuffer cmd, Camera camera, Matrix4x4 projscr, Matrix4x4 invProjscr, RenderTargetIdentifier cameraDepthBufferRT)
             {
                 // clear atomic offset index
-                cmd.SetComputeBufferParam(buildPerVoxelLightListShader, s_ClearVoxelAtomicKernel, "g_LayeredSingleIdxBuffer", s_GlobalLightListAtomic);
+                cmd.SetComputeBufferParam(buildPerVoxelLightListShader, s_ClearVoxelAtomicKernel, HDShaderIDs.g_LayeredSingleIdxBuffer, s_GlobalLightListAtomic);
-                cmd.SetComputeIntParam(buildPerVoxelLightListShader, "_EnvLightIndexShift", m_lightList.lights.Count);
-                cmd.SetComputeIntParam(buildPerVoxelLightListShader, "g_iNrVisibLights", m_lightCount);
-                cmd.SetComputeMatrixParam(buildPerVoxelLightListShader, "g_mScrProjection", projscr);
-                cmd.SetComputeMatrixParam(buildPerVoxelLightListShader, "g_mInvScrProjection", invProjscr);
+                cmd.SetComputeIntParam(buildPerVoxelLightListShader, HDShaderIDs._EnvLightIndexShift, m_lightList.lights.Count);
+                cmd.SetComputeIntParam(buildPerVoxelLightListShader, HDShaderIDs.g_iNrVisibLights, m_lightCount);
+                cmd.SetComputeMatrixParam(buildPerVoxelLightListShader, HDShaderIDs.g_mScrProjection, projscr);
+                cmd.SetComputeMatrixParam(buildPerVoxelLightListShader, HDShaderIDs.g_mInvScrProjection, invProjscr);
-                cmd.SetComputeIntParam(buildPerVoxelLightListShader, "g_iLog2NumClusters", k_Log2NumClusters);
+                cmd.SetComputeIntParam(buildPerVoxelLightListShader, HDShaderIDs.g_iLog2NumClusters, k_Log2NumClusters);
 
                 //Vector4 v2_near = invProjscr * new Vector4(0.0f, 0.0f, 0.0f, 1.0f);
                 //Vector4 v2_far = invProjscr * new Vector4(0.0f, 0.0f, 1.0f, 1.0f);
                 var farPlane = camera.farClipPlane;
-                cmd.SetComputeFloatParam(buildPerVoxelLightListShader, "g_fNearPlane", nearPlane);
-                cmd.SetComputeFloatParam(buildPerVoxelLightListShader, "g_fFarPlane", farPlane);
+                cmd.SetComputeFloatParam(buildPerVoxelLightListShader, HDShaderIDs.g_fNearPlane, nearPlane);
+                cmd.SetComputeFloatParam(buildPerVoxelLightListShader, HDShaderIDs.g_fFarPlane, farPlane);
-                cmd.SetComputeFloatParam(buildPerVoxelLightListShader, "g_fClustScale", m_ClustScale);
-                cmd.SetComputeFloatParam(buildPerVoxelLightListShader, "g_fClustBase", k_ClustLogBase);
+                cmd.SetComputeFloatParam(buildPerVoxelLightListShader, HDShaderIDs.g_fClustScale, m_ClustScale);
+                cmd.SetComputeFloatParam(buildPerVoxelLightListShader, HDShaderIDs.g_fClustBase, k_ClustLogBase);
-                cmd.SetComputeTextureParam(buildPerVoxelLightListShader, s_GenListPerVoxelKernel, "g_depth_tex", cameraDepthBufferRT);
-                cmd.SetComputeBufferParam(buildPerVoxelLightListShader, s_GenListPerVoxelKernel, "g_vLayeredLightList", s_PerVoxelLightLists);
-                cmd.SetComputeBufferParam(buildPerVoxelLightListShader, s_GenListPerVoxelKernel, "g_LayeredOffset", s_PerVoxelOffset);
-                cmd.SetComputeBufferParam(buildPerVoxelLightListShader, s_GenListPerVoxelKernel, "g_LayeredSingleIdxBuffer", s_GlobalLightListAtomic);
+                cmd.SetComputeTextureParam(buildPerVoxelLightListShader, s_GenListPerVoxelKernel, HDShaderIDs.g_depth_tex, cameraDepthBufferRT);
+                cmd.SetComputeBufferParam(buildPerVoxelLightListShader, s_GenListPerVoxelKernel, HDShaderIDs.g_vLayeredLightList, s_PerVoxelLightLists);
+                cmd.SetComputeBufferParam(buildPerVoxelLightListShader, s_GenListPerVoxelKernel, HDShaderIDs.g_LayeredOffset, s_PerVoxelOffset);
+                cmd.SetComputeBufferParam(buildPerVoxelLightListShader, s_GenListPerVoxelKernel, HDShaderIDs.g_LayeredSingleIdxBuffer, s_GlobalLightListAtomic);
-                    cmd.SetComputeBufferParam(buildPerVoxelLightListShader, s_GenListPerVoxelKernel, "g_vBigTileLightList", s_BigTileLightList);
+                    cmd.SetComputeBufferParam(buildPerVoxelLightListShader, s_GenListPerVoxelKernel, HDShaderIDs.g_vBigTileLightList, s_BigTileLightList);
-                    cmd.SetComputeBufferParam(buildPerVoxelLightListShader, s_GenListPerVoxelKernel, "g_logBaseBuffer", s_PerTileLogBaseTweak);
+                    cmd.SetComputeBufferParam(buildPerVoxelLightListShader, s_GenListPerVoxelKernel, HDShaderIDs.g_logBaseBuffer, s_PerTileLogBaseTweak);
-                cmd.SetComputeBufferParam(buildPerVoxelLightListShader, s_GenListPerVoxelKernel, "g_vBoundsBuffer", s_AABBBoundsBuffer);
-                cmd.SetComputeBufferParam(buildPerVoxelLightListShader, s_GenListPerVoxelKernel, "_LightVolumeData", s_LightVolumeDataBuffer);
-                cmd.SetComputeBufferParam(buildPerVoxelLightListShader, s_GenListPerVoxelKernel, "g_data", s_ConvexBoundsBuffer);
+                cmd.SetComputeBufferParam(buildPerVoxelLightListShader, s_GenListPerVoxelKernel, HDShaderIDs.g_vBoundsBuffer, s_AABBBoundsBuffer);
+                cmd.SetComputeBufferParam(buildPerVoxelLightListShader, s_GenListPerVoxelKernel, HDShaderIDs._LightVolumeData, s_LightVolumeDataBuffer);
+                cmd.SetComputeBufferParam(buildPerVoxelLightListShader, s_GenListPerVoxelKernel, HDShaderIDs.g_data, s_ConvexBoundsBuffer);
 
                 var numTilesX = GetNumTileClusteredX(camera);
                 var numTilesY = GetNumTileClusteredY(camera);
-            public void BuildGPULightLists(Camera camera, CommandBuffer cmd, RenderTargetIdentifier cameraDepthBufferRT)
+            public void BuildGPULightLists(Camera camera, CommandBuffer cmd, RenderTargetIdentifier cameraDepthBufferRT, RenderTargetIdentifier stencilTextureRT)
             {
                 var w = camera.pixelWidth;
                 var h = camera.pixelHeight;
                     var projh = temp * proj;
                     var invProjh = projh.inverse;
 
-                    cmd.SetComputeIntParam(buildScreenAABBShader, "g_iNrVisibLights", m_lightCount);
-                    cmd.SetComputeBufferParam(buildScreenAABBShader, s_GenAABBKernel, "g_data", s_ConvexBoundsBuffer);
+                    cmd.SetComputeIntParam(buildScreenAABBShader, HDShaderIDs.g_iNrVisibLights, m_lightCount);
+                    cmd.SetComputeBufferParam(buildScreenAABBShader, s_GenAABBKernel, HDShaderIDs.g_data, s_ConvexBoundsBuffer);
-                    cmd.SetComputeMatrixParam(buildScreenAABBShader, "g_mProjection", projh);
-                    cmd.SetComputeMatrixParam(buildScreenAABBShader, "g_mInvProjection", invProjh);
-                    cmd.SetComputeBufferParam(buildScreenAABBShader, s_GenAABBKernel, "g_vBoundsBuffer", s_AABBBoundsBuffer);
+                    cmd.SetComputeMatrixParam(buildScreenAABBShader, HDShaderIDs.g_mProjection, projh);
+                    cmd.SetComputeMatrixParam(buildScreenAABBShader, HDShaderIDs.g_mInvProjection, invProjh);
+                    cmd.SetComputeBufferParam(buildScreenAABBShader, s_GenAABBKernel, HDShaderIDs.g_vBoundsBuffer, s_AABBBoundsBuffer);
                     cmd.DispatchCompute(buildScreenAABBShader, s_GenAABBKernel, (m_lightCount + 7) / 8, 1, 1);
                 }
 
-                    cmd.SetComputeIntParams(buildPerBigTileLightListShader, "g_viDimensions", w, h);
-                    cmd.SetComputeIntParam(buildPerBigTileLightListShader, "_EnvLightIndexShift", m_lightList.lights.Count);
-                    cmd.SetComputeIntParam(buildPerBigTileLightListShader, "g_iNrVisibLights", m_lightCount);
-                    cmd.SetComputeMatrixParam(buildPerBigTileLightListShader, "g_mScrProjection", projscr);
-                    cmd.SetComputeMatrixParam(buildPerBigTileLightListShader, "g_mInvScrProjection", invProjscr);
-                    cmd.SetComputeFloatParam(buildPerBigTileLightListShader, "g_fNearPlane", camera.nearClipPlane);
-                    cmd.SetComputeFloatParam(buildPerBigTileLightListShader, "g_fFarPlane", camera.farClipPlane);
-                    cmd.SetComputeBufferParam(buildPerBigTileLightListShader, s_GenListPerBigTileKernel, "g_vLightList", s_BigTileLightList);
-                    cmd.SetComputeBufferParam(buildPerBigTileLightListShader, s_GenListPerBigTileKernel, "g_vBoundsBuffer", s_AABBBoundsBuffer);
-                    cmd.SetComputeBufferParam(buildPerBigTileLightListShader, s_GenListPerBigTileKernel, "_LightVolumeData", s_LightVolumeDataBuffer);
-                    cmd.SetComputeBufferParam(buildPerBigTileLightListShader, s_GenListPerBigTileKernel, "g_data", s_ConvexBoundsBuffer);
+                    cmd.SetComputeIntParams(buildPerBigTileLightListShader, HDShaderIDs.g_viDimensions, w, h);
+                    cmd.SetComputeIntParam(buildPerBigTileLightListShader, HDShaderIDs._EnvLightIndexShift, m_lightList.lights.Count);
+                    cmd.SetComputeIntParam(buildPerBigTileLightListShader, HDShaderIDs.g_iNrVisibLights, m_lightCount);
+                    cmd.SetComputeMatrixParam(buildPerBigTileLightListShader, HDShaderIDs.g_mScrProjection, projscr);
+                    cmd.SetComputeMatrixParam(buildPerBigTileLightListShader, HDShaderIDs.g_mInvScrProjection, invProjscr);
+                    cmd.SetComputeFloatParam(buildPerBigTileLightListShader, HDShaderIDs.g_fNearPlane, camera.nearClipPlane);
+                    cmd.SetComputeFloatParam(buildPerBigTileLightListShader, HDShaderIDs.g_fFarPlane, camera.farClipPlane);
+                    cmd.SetComputeBufferParam(buildPerBigTileLightListShader, s_GenListPerBigTileKernel, HDShaderIDs.g_vLightList, s_BigTileLightList);
+                    cmd.SetComputeBufferParam(buildPerBigTileLightListShader, s_GenListPerBigTileKernel, HDShaderIDs.g_vBoundsBuffer, s_AABBBoundsBuffer);
+                    cmd.SetComputeBufferParam(buildPerBigTileLightListShader, s_GenListPerBigTileKernel, HDShaderIDs._LightVolumeData, s_LightVolumeDataBuffer);
+                    cmd.SetComputeBufferParam(buildPerBigTileLightListShader, s_GenListPerBigTileKernel, HDShaderIDs.g_data, s_ConvexBoundsBuffer);
                     cmd.DispatchCompute(buildPerBigTileLightListShader, s_GenListPerBigTileKernel, numBigTilesX, numBigTilesY, 1);
                 }
 
-                bool enableFeatureVariants = GetFeatureVariantsEnabled();
+                bool enableFeatureVariants = GetFeatureVariantsEnabled(m_TileSettings);
-                    cmd.SetComputeIntParams(buildPerTileLightListShader, "g_viDimensions", w, h);
-                    cmd.SetComputeIntParam(buildPerTileLightListShader, "_EnvLightIndexShift", m_lightList.lights.Count);
-                    cmd.SetComputeIntParam(buildPerTileLightListShader, "g_iNrVisibLights", m_lightCount);
+                    cmd.SetComputeIntParams(buildPerTileLightListShader, HDShaderIDs.g_viDimensions, w, h);
+                    cmd.SetComputeIntParam(buildPerTileLightListShader, HDShaderIDs._EnvLightIndexShift, m_lightList.lights.Count);
+                    cmd.SetComputeIntParam(buildPerTileLightListShader, HDShaderIDs.g_iNrVisibLights, m_lightCount);
-                    cmd.SetComputeBufferParam(buildPerTileLightListShader, s_GenListPerTileKernel, "g_vBoundsBuffer", s_AABBBoundsBuffer);
-                    cmd.SetComputeBufferParam(buildPerTileLightListShader, s_GenListPerTileKernel, "_LightVolumeData", s_LightVolumeDataBuffer);
-                    cmd.SetComputeBufferParam(buildPerTileLightListShader, s_GenListPerTileKernel, "g_data", s_ConvexBoundsBuffer);
+                    cmd.SetComputeBufferParam(buildPerTileLightListShader, s_GenListPerTileKernel, HDShaderIDs.g_vBoundsBuffer, s_AABBBoundsBuffer);
+                    cmd.SetComputeBufferParam(buildPerTileLightListShader, s_GenListPerTileKernel, HDShaderIDs._LightVolumeData, s_LightVolumeDataBuffer);
+                    cmd.SetComputeBufferParam(buildPerTileLightListShader, s_GenListPerTileKernel, HDShaderIDs.g_data, s_ConvexBoundsBuffer);
-                    cmd.SetComputeMatrixParam(buildPerTileLightListShader, "g_mScrProjection", projscr);
-                    cmd.SetComputeMatrixParam(buildPerTileLightListShader, "g_mInvScrProjection", invProjscr);
-                    cmd.SetComputeTextureParam(buildPerTileLightListShader, s_GenListPerTileKernel, "g_depth_tex", cameraDepthBufferRT);
-                    cmd.SetComputeBufferParam(buildPerTileLightListShader, s_GenListPerTileKernel, "g_vLightList", s_LightList);
+                    cmd.SetComputeMatrixParam(buildPerTileLightListShader, HDShaderIDs.g_mScrProjection, projscr);
+                    cmd.SetComputeMatrixParam(buildPerTileLightListShader, HDShaderIDs.g_mInvScrProjection, invProjscr);
+                    cmd.SetComputeTextureParam(buildPerTileLightListShader, s_GenListPerTileKernel, HDShaderIDs.g_depth_tex, cameraDepthBufferRT);
+                    cmd.SetComputeBufferParam(buildPerTileLightListShader, s_GenListPerTileKernel, HDShaderIDs.g_vLightList, s_LightList);
-                        cmd.SetComputeBufferParam(buildPerTileLightListShader, s_GenListPerTileKernel, "g_vBigTileLightList", s_BigTileLightList);
+                        cmd.SetComputeBufferParam(buildPerTileLightListShader, s_GenListPerTileKernel, HDShaderIDs.g_vBigTileLightList, s_BigTileLightList);
 
                     if (enableFeatureVariants)
                     {
                             baseFeatureFlags |= (uint)LightFeatureFlags.Directional;
                         }
-                        if (Shader.GetGlobalInt("_EnvLightSkyEnabled") != 0)
+                        if (Shader.GetGlobalInt(HDShaderIDs._EnvLightSkyEnabled) != 0)
                         {
                             baseFeatureFlags |= (uint)LightFeatureFlags.Sky;
                         }
                         }
-                        cmd.SetComputeIntParam(buildPerTileLightListShader, "g_BaseFeatureFlags", (int)baseFeatureFlags);
-                        cmd.SetComputeBufferParam(buildPerTileLightListShader, s_GenListPerTileKernel, "g_TileFeatureFlags", s_TileFeatureFlags);
+                        cmd.SetComputeIntParam(buildPerTileLightListShader, HDShaderIDs.g_BaseFeatureFlags, (int)baseFeatureFlags);
+                        cmd.SetComputeBufferParam(buildPerTileLightListShader, s_GenListPerTileKernel, HDShaderIDs.g_TileFeatureFlags, s_TileFeatureFlags);
                     }
 
                     cmd.DispatchCompute(buildPerTileLightListShader, s_GenListPerTileKernel, numTilesX, numTilesY, 1);
                             baseFeatureFlags |= LightDefinitions.s_LightFeatureMaskFlags;
                         }
 
-                        cmd.SetComputeIntParam(buildMaterialFlagsShader, "g_BaseFeatureFlags", (int)baseFeatureFlags);
-                        cmd.SetComputeIntParams(buildMaterialFlagsShader, "g_viDimensions", w, h);
-                        cmd.SetComputeBufferParam(buildMaterialFlagsShader, buildMaterialFlagsKernel, "g_TileFeatureFlags", s_TileFeatureFlags);
+                        cmd.SetComputeIntParam(buildMaterialFlagsShader, HDShaderIDs.g_BaseFeatureFlags, (int)baseFeatureFlags);
+                        cmd.SetComputeIntParams(buildMaterialFlagsShader, HDShaderIDs.g_viDimensions, w, h);
+                        cmd.SetComputeBufferParam(buildMaterialFlagsShader, buildMaterialFlagsKernel, HDShaderIDs.g_TileFeatureFlags, s_TileFeatureFlags);
-                        cmd.SetComputeTextureParam(buildMaterialFlagsShader, buildMaterialFlagsKernel, "g_depth_tex", cameraDepthBufferRT);
-                        cmd.SetComputeTextureParam(buildMaterialFlagsShader, buildMaterialFlagsKernel, "_GBufferTexture0", Shader.PropertyToID("_GBufferTexture0"));
-                        cmd.SetComputeTextureParam(buildMaterialFlagsShader, buildMaterialFlagsKernel, "_GBufferTexture1", Shader.PropertyToID("_GBufferTexture1"));
-                        cmd.SetComputeTextureParam(buildMaterialFlagsShader, buildMaterialFlagsKernel, "_GBufferTexture2", Shader.PropertyToID("_GBufferTexture2"));
-                        cmd.SetComputeTextureParam(buildMaterialFlagsShader, buildMaterialFlagsKernel, "_GBufferTexture3", Shader.PropertyToID("_GBufferTexture3"));
+                        cmd.SetComputeTextureParam(buildMaterialFlagsShader, buildMaterialFlagsKernel, HDShaderIDs._StencilTexture, stencilTextureRT);
+                        cmd.SetComputeTextureParam(buildMaterialFlagsShader, buildMaterialFlagsKernel, HDShaderIDs._GBufferTexture0, HDShaderIDs._GBufferTexture0);
+                        cmd.SetComputeTextureParam(buildMaterialFlagsShader, buildMaterialFlagsKernel, HDShaderIDs._GBufferTexture1, HDShaderIDs._GBufferTexture1);
+                        cmd.SetComputeTextureParam(buildMaterialFlagsShader, buildMaterialFlagsKernel, HDShaderIDs._GBufferTexture2, HDShaderIDs._GBufferTexture2);
+                        cmd.SetComputeTextureParam(buildMaterialFlagsShader, buildMaterialFlagsKernel, HDShaderIDs._GBufferTexture3, HDShaderIDs._GBufferTexture3);
-                    cmd.SetComputeBufferParam(clearDispatchIndirectShader, s_ClearDispatchIndirectKernel, "g_DispatchIndirectBuffer", s_DispatchIndirectBuffer);
+                    cmd.SetComputeBufferParam(clearDispatchIndirectShader, s_ClearDispatchIndirectKernel, HDShaderIDs.g_DispatchIndirectBuffer, s_DispatchIndirectBuffer);
-                    cmd.SetComputeBufferParam(buildDispatchIndirectShader, s_BuildDispatchIndirectKernel, "g_DispatchIndirectBuffer", s_DispatchIndirectBuffer);
-                    cmd.SetComputeBufferParam(buildDispatchIndirectShader, s_BuildDispatchIndirectKernel, "g_TileList", s_TileList);
-                    cmd.SetComputeBufferParam(buildDispatchIndirectShader, s_BuildDispatchIndirectKernel, "g_TileFeatureFlags", s_TileFeatureFlags);
-                    cmd.SetComputeIntParam(buildDispatchIndirectShader, "g_NumTiles", numTiles);
-                    cmd.SetComputeIntParam(buildDispatchIndirectShader, "g_NumTilesX", numTilesX);
+                    cmd.SetComputeBufferParam(buildDispatchIndirectShader, s_BuildDispatchIndirectKernel, HDShaderIDs.g_DispatchIndirectBuffer, s_DispatchIndirectBuffer);
+                    cmd.SetComputeBufferParam(buildDispatchIndirectShader, s_BuildDispatchIndirectKernel, HDShaderIDs.g_TileList, s_TileList);
+                    cmd.SetComputeBufferParam(buildDispatchIndirectShader, s_BuildDispatchIndirectKernel, HDShaderIDs.g_TileFeatureFlags, s_TileFeatureFlags);
+                    cmd.SetComputeIntParam(buildDispatchIndirectShader, HDShaderIDs.g_NumTiles, numTiles);
+                    cmd.SetComputeIntParam(buildDispatchIndirectShader, HDShaderIDs.g_NumTilesX, numTilesX);
                     cmd.DispatchCompute(buildDispatchIndirectShader, s_BuildDispatchIndirectKernel, (numTiles + 63) / 64, 1, 1);
                 }
             }
                 activeCommandBuffer = commandBuffer;
             }
 
-            private void SetGlobalTexture(string name, Texture value)
+            private void SetGlobalTexture(int nameID, Texture value)
-                    activeCommandBuffer.SetComputeTextureParam(activeComputeShader, activeComputeKernel, name, value);
+                    activeCommandBuffer.SetComputeTextureParam(activeComputeShader, activeComputeKernel, nameID, value);
-                    activeCommandBuffer.SetGlobalTexture(name, value);
+                    activeCommandBuffer.SetGlobalTexture(nameID, value);
-            private void SetGlobalBuffer(string name, ComputeBuffer buffer)
+            private void SetGlobalBuffer(int nameID, ComputeBuffer buffer)
-                    activeCommandBuffer.SetComputeBufferParam(activeComputeShader, activeComputeKernel, name, buffer);
+                    activeCommandBuffer.SetComputeBufferParam(activeComputeShader, activeComputeKernel, nameID, buffer);
-                    activeCommandBuffer.SetGlobalBuffer(name, buffer);
+                    activeCommandBuffer.SetGlobalBuffer(nameID, buffer);
-            private void SetGlobalInt(string name, int value)
+            private void SetGlobalInt(int nameID, int value)
-                    activeCommandBuffer.SetComputeIntParam(activeComputeShader, name, value);
+                    activeCommandBuffer.SetComputeIntParam(activeComputeShader, nameID, value);
-                    Shader.SetGlobalInt(name, value);
+                    Shader.SetGlobalInt(nameID, value);
-            private void SetGlobalFloat(string name, float value)
+            private void SetGlobalFloat(int nameID, float value)
-                    activeCommandBuffer.SetComputeFloatParam(activeComputeShader, name, value);
+                    activeCommandBuffer.SetComputeFloatParam(activeComputeShader, nameID, value);
-                    activeCommandBuffer.SetGlobalFloat(name, value);
+                    activeCommandBuffer.SetGlobalFloat(nameID, value);
-            private void SetGlobalVector(string name, Vector4 value)
+            private void SetGlobalVector(int nameID, Vector4 value)
-                    activeCommandBuffer.SetComputeVectorParam(activeComputeShader, name, value);
+                    activeCommandBuffer.SetComputeVectorParam(activeComputeShader, nameID, value);
-                    activeCommandBuffer.SetGlobalVector(name, value);
+                    activeCommandBuffer.SetGlobalVector(nameID, value);
-            private void SetGlobalVectorArray(string name, Vector4[] values)
+            private void SetGlobalVectorArray(int nameID, Vector4[] values)
-                    int numVectors = values.Length;
-                    var data = new float[numVectors * 4];
-
-                    for (int n = 0; n < numVectors; n++)
-                    {
-                        for (int i = 0; i < 4; i++)
-                        {
-                            data[4 * n + i] = values[n][i];
-                        }
-                    }
-
-                    activeCommandBuffer.SetComputeFloatParams(activeComputeShader, name, data);
+                    activeCommandBuffer.SetComputeVectorArrayParam(activeComputeShader, nameID, values);
-                    activeCommandBuffer.SetGlobalVectorArray(name, values);
+                    activeCommandBuffer.SetGlobalVectorArray(nameID, values);
                 }
             }
 
             {
                 m_ShadowMgr.BindResources(cmd, activeComputeShader, activeComputeKernel);
 
-                SetGlobalBuffer("g_vLightListGlobal", !usingFptl ? s_PerVoxelLightLists : s_LightList);       // opaques list (unless MSAA possibly)
+                SetGlobalBuffer(HDShaderIDs.g_vLightListGlobal, !usingFptl ? s_PerVoxelLightLists : s_LightList);       // opaques list (unless MSAA possibly)
-                SetGlobalTexture("_CookieTextures", m_CookieTexArray.GetTexCache());
-                SetGlobalTexture("_CookieCubeTextures", m_CubeCookieTexArray.GetTexCache());
-                SetGlobalTexture("_EnvTextures", m_CubeReflTexArray.GetTexCache());
+                SetGlobalTexture(HDShaderIDs._CookieTextures, m_CookieTexArray.GetTexCache());
+                SetGlobalTexture(HDShaderIDs._CookieCubeTextures, m_CubeCookieTexArray.GetTexCache());
+                SetGlobalTexture(HDShaderIDs._EnvTextures, m_CubeReflTexArray.GetTexCache());
-                SetGlobalBuffer("_DirectionalLightDatas", s_DirectionalLightDatas);
-                SetGlobalInt("_DirectionalLightCount", m_lightList.directionalLights.Count);
-                SetGlobalBuffer("_LightDatas", s_LightDatas);
-                SetGlobalInt("_PunctualLightCount", m_punctualLightCount);
-                SetGlobalInt("_AreaLightCount", m_areaLightCount);
-                SetGlobalBuffer("_EnvLightDatas", s_EnvLightDatas);
-                SetGlobalInt("_EnvLightCount", m_lightList.envLights.Count);
-                SetGlobalBuffer("_ShadowDatas", s_shadowDatas);
-                SetGlobalVectorArray("_DirShadowSplitSpheres", m_lightList.directionalShadowSplitSphereSqr);
+                SetGlobalBuffer(HDShaderIDs._DirectionalLightDatas, s_DirectionalLightDatas);
+                SetGlobalInt(HDShaderIDs._DirectionalLightCount, m_lightList.directionalLights.Count);
+                SetGlobalBuffer(HDShaderIDs._LightDatas, s_LightDatas);
+                SetGlobalInt(HDShaderIDs._PunctualLightCount, m_punctualLightCount);
+                SetGlobalInt(HDShaderIDs._AreaLightCount, m_areaLightCount);
+                SetGlobalBuffer(HDShaderIDs._EnvLightDatas, s_EnvLightDatas);
+                SetGlobalInt(HDShaderIDs._EnvLightCount, m_lightList.envLights.Count);
+                SetGlobalBuffer(HDShaderIDs._ShadowDatas, s_shadowDatas);
+                SetGlobalVectorArray(HDShaderIDs._DirShadowSplitSpheres, m_lightList.directionalShadowSplitSphereSqr);
-                SetGlobalInt("_NumTileFtplX", GetNumTileFtplX(camera));
-                SetGlobalInt("_NumTileFtplY", GetNumTileFtplY(camera));
+                SetGlobalInt(HDShaderIDs._NumTileFtplX, GetNumTileFtplX(camera));
+                SetGlobalInt(HDShaderIDs._NumTileFtplY, GetNumTileFtplY(camera));
-                SetGlobalInt("_NumTileClusteredX", GetNumTileClusteredX(camera));
-                SetGlobalInt("_NumTileClusteredY", GetNumTileClusteredY(camera));
+                SetGlobalInt(HDShaderIDs._NumTileClusteredX, GetNumTileClusteredX(camera));
+                SetGlobalInt(HDShaderIDs._NumTileClusteredY, GetNumTileClusteredY(camera));
-                    SetGlobalBuffer("g_vBigTileLightList", s_BigTileLightList);
+                    SetGlobalBuffer(HDShaderIDs.g_vBigTileLightList, s_BigTileLightList);
-                {
-                    SetGlobalFloat("g_fClustScale", m_ClustScale);
-                    SetGlobalFloat("g_fClustBase", k_ClustLogBase);
-                    SetGlobalFloat("g_fNearPlane", camera.nearClipPlane);
-                    SetGlobalFloat("g_fFarPlane", camera.farClipPlane);
-                    SetGlobalFloat("g_iLog2NumClusters", k_Log2NumClusters);
+               {
+                    SetGlobalFloat(HDShaderIDs.g_fClustScale, m_ClustScale);
+                    SetGlobalFloat(HDShaderIDs.g_fClustBase, k_ClustLogBase);
+                    SetGlobalFloat(HDShaderIDs.g_fNearPlane, camera.nearClipPlane);
+                    SetGlobalFloat(HDShaderIDs.g_fFarPlane, camera.farClipPlane);
+                    SetGlobalInt(HDShaderIDs.g_iLog2NumClusters, k_Log2NumClusters);
-                    SetGlobalFloat("g_isLogBaseBufferEnabled", k_UseDepthBuffer ? 1 : 0);
+                    SetGlobalInt(HDShaderIDs.g_isLogBaseBufferEnabled, k_UseDepthBuffer ? 1 : 0);
-                    SetGlobalBuffer("g_vLayeredOffsetsBuffer", s_PerVoxelOffset);
+                    SetGlobalBuffer(HDShaderIDs.g_vLayeredOffsetsBuffer, s_PerVoxelOffset);
-                        SetGlobalBuffer("g_logBaseBuffer", s_PerTileLogBaseTweak);
+                        SetGlobalBuffer(HDShaderIDs.g_logBaseBuffer, s_PerTileLogBaseTweak);
                     }
                 }
             }
                     PushGlobalParams(hdCamera.camera, cmd, null, 0);
                     if (lightingDebug.tileDebugByCategory == TileSettings.TileDebug.FeatureVariants)
                     {
-                        if (GetFeatureVariantsEnabled())
+                        if (GetFeatureVariantsEnabled(m_TileSettings))
-                            m_DebugViewTilesMaterial.SetInt("_NumTiles", numTiles);
-                            m_DebugViewTilesMaterial.SetInt("_ViewTilesFlags", (int)lightingDebug.tileDebugByCategory);
-                            m_DebugViewTilesMaterial.SetVector("_MousePixelCoord", mousePixelCoord);
-                            m_DebugViewTilesMaterial.SetBuffer("g_TileList", s_TileList);
-                            m_DebugViewTilesMaterial.SetBuffer("g_DispatchIndirectBuffer", s_DispatchIndirectBuffer);
+                            m_DebugViewTilesMaterial.SetInt(HDShaderIDs._NumTiles, numTiles);
+                            m_DebugViewTilesMaterial.SetInt(HDShaderIDs._ViewTilesFlags, (int)lightingDebug.tileDebugByCategory);
+                            m_DebugViewTilesMaterial.SetVector(HDShaderIDs._MousePixelCoord, mousePixelCoord);
+                            m_DebugViewTilesMaterial.SetBuffer(HDShaderIDs.g_TileList, s_TileList);
+                            m_DebugViewTilesMaterial.SetBuffer(HDShaderIDs.g_DispatchIndirectBuffer, s_DispatchIndirectBuffer);
                             m_DebugViewTilesMaterial.EnableKeyword(bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
                             m_DebugViewTilesMaterial.DisableKeyword(!bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
                             m_DebugViewTilesMaterial.DisableKeyword("SHOW_LIGHT_CATEGORIES");
                     else if (lightingDebug.tileDebugByCategory != TileSettings.TileDebug.None)
                     {
                         // lightCategories
-                        m_DebugViewTilesMaterial.SetInt("_ViewTilesFlags", (int)lightingDebug.tileDebugByCategory);
-                        m_DebugViewTilesMaterial.SetVector("_MousePixelCoord", mousePixelCoord);
+                        m_DebugViewTilesMaterial.SetInt(HDShaderIDs._ViewTilesFlags, (int)lightingDebug.tileDebugByCategory);
+                        m_DebugViewTilesMaterial.SetVector(HDShaderIDs._MousePixelCoord, mousePixelCoord);
                         m_DebugViewTilesMaterial.EnableKeyword(bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
                         m_DebugViewTilesMaterial.DisableKeyword(!bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
                         m_DebugViewTilesMaterial.EnableKeyword("SHOW_LIGHT_CATEGORIES");
             {
                 var bUseClusteredForDeferred = !usingFptl;
 
-                if (m_TileSettings.enableComputeLightEvaluation && outputSplitLighting)
+                if (m_TileSettings.enableTileAndCluster && m_TileSettings.enableComputeLightEvaluation && outputSplitLighting)
-                // TODO: To reduce GC pressure don't do concat string here
-                using (new Utilities.ProfilingSample((m_TileSettings.enableTileAndCluster ? "TilePass - Deferred Lighting Pass" : "SinglePass - Deferred Lighting Pass") + (outputSplitLighting ? " MRT" : ""), cmd))
+                // Predeclared to reduce GC pressure
+                string tilePassName = "TilePass - Deferred Lighting Pass";
+                string tilePassMRTName = "TilePass - Deferred Lighting Pass MRT";
+                string singlePassName = "SinglePass - Deferred Lighting Pass";
+                string SinglePassMRTName = "SinglePass - Deferred Lighting Pass MRT";
+
+                using (new Utilities.ProfilingSample(m_TileSettings.enableTileAndCluster ?
+                                                            (outputSplitLighting ? tilePassMRTName : tilePassName) :
+                                                            (outputSplitLighting ? SinglePassMRTName : singlePassName), cmd))
                 {
                     var camera = hdCamera.camera;
 
                             // If SSS is disable, do lighting for both split lighting and no split lighting
                             if (!debugDisplaySettings.renderingDebugSettings.enableSSSAndTransmission)
                             {
-                                m_SingleDeferredMaterialSRT.SetInt("_StencilRef", (int)StencilLightingUsage.NoLighting);
-                                m_SingleDeferredMaterialSRT.SetInt("_StencilCmp", (int)CompareFunction.NotEqual);
+                                m_SingleDeferredMaterialSRT.SetInt(HDShaderIDs._StencilRef, (int)StencilLightingUsage.NoLighting);
+                                m_SingleDeferredMaterialSRT.SetInt(HDShaderIDs._StencilCmp, (int)CompareFunction.NotEqual);
-                                m_SingleDeferredMaterialSRT.SetInt("_StencilRef", (int)StencilLightingUsage.RegularLighting);
-                                m_SingleDeferredMaterialSRT.SetInt("_StencilCmp", (int)CompareFunction.Equal);
+                                m_SingleDeferredMaterialSRT.SetInt(HDShaderIDs._StencilRef, (int)StencilLightingUsage.RegularLighting);
+                                m_SingleDeferredMaterialSRT.SetInt(HDShaderIDs._StencilCmp, (int)CompareFunction.Equal);
                             }
 
                             Utilities.DrawFullScreen(cmd, m_SingleDeferredMaterialSRT, colorBuffers[0], depthStencilBuffer);
 
                         if (m_TileSettings.enableComputeLightEvaluation)
                         {
-                            bool enableFeatureVariants = GetFeatureVariantsEnabled() && !debugDisplaySettings.IsDebugDisplayEnabled();
+                            bool enableFeatureVariants = GetFeatureVariantsEnabled(m_TileSettings) && !debugDisplaySettings.IsDebugDisplayEnabled();
+                            int debugViewMaterial = Shader.GetGlobalInt(HDShaderIDs._DebugViewMaterial);
+                            int debugLightingMode = Shader.GetGlobalInt(HDShaderIDs._DebugLightingMode);
+                            Vector4 debugLightingAlbedo = Shader.GetGlobalVector(HDShaderIDs._DebugLightingAlbedo);
+                            Vector4 debugLightingSmoothness = Shader.GetGlobalVector(HDShaderIDs._DebugLightingSmoothness);
-                            int debugViewMaterial = Shader.GetGlobalInt("_DebugViewMaterial");
-                            int debugLightingMode = Shader.GetGlobalInt("_DebugLightingMode");
-                            Vector4 debugLightingAlbedo = Shader.GetGlobalVector("_DebugLightingAlbedo");
-                            Vector4 debugLightingSmoothness = Shader.GetGlobalVector("_DebugLightingSmoothness");
+                            Texture ltcData = Shader.GetGlobalTexture(HDShaderIDs._LtcData);
+                            Texture preIntegratedFGD = Shader.GetGlobalTexture(HDShaderIDs._PreIntegratedFGD);
+                            Texture ltcGGXMatrix = Shader.GetGlobalTexture(HDShaderIDs._LtcGGXMatrix);
+                            Texture ltcDisneyDiffuseMatrix = Shader.GetGlobalTexture(HDShaderIDs._LtcDisneyDiffuseMatrix);
+                            Texture ltcMultiGGXFresnelDisneyDiffuse = Shader.GetGlobalTexture(HDShaderIDs._LtcMultiGGXFresnelDisneyDiffuse);
-                            int gbufferTexture0 = Shader.PropertyToID("_GBufferTexture0");
-                            int gbufferTexture1 = Shader.PropertyToID("_GBufferTexture1");
-                            int gbufferTexture2 = Shader.PropertyToID("_GBufferTexture2");
-                            int gbufferTexture3 = Shader.PropertyToID("_GBufferTexture3");
-                            int ambientOcclusionTexture = Shader.PropertyToID("_AmbientOcclusionTexture");
+                            Matrix4x4 invScrProjection = Shader.GetGlobalMatrix(HDShaderIDs.g_mInvScrProjection);
+                            int useTileLightList = Shader.GetGlobalInt(HDShaderIDs._UseTileLightList);
-                            Texture ltcData = Shader.GetGlobalTexture(Shader.PropertyToID("_LtcData"));
-                            Texture preIntegratedFGD = Shader.GetGlobalTexture("_PreIntegratedFGD");
-                            Texture ltcGGXMatrix = Shader.GetGlobalTexture("_LtcGGXMatrix");
-                            Texture ltcDisneyDiffuseMatrix = Shader.GetGlobalTexture("_LtcDisneyDiffuseMatrix");
-                            Texture ltcMultiGGXFresnelDisneyDiffuse = Shader.GetGlobalTexture("_LtcMultiGGXFresnelDisneyDiffuse");
-
-                            Matrix4x4 invScrProjection = Shader.GetGlobalMatrix("g_mInvScrProjection");
-                            int useTileLightList = Shader.GetGlobalInt("_UseTileLightList");
+                            Vector4 time = Shader.GetGlobalVector(HDShaderIDs._Time);
+                            Vector4 sinTime = Shader.GetGlobalVector(HDShaderIDs._SinTime);
+                            Vector4 cosTime = Shader.GetGlobalVector(HDShaderIDs._CosTime);
+                            Vector4 unity_DeltaTime = Shader.GetGlobalVector(HDShaderIDs.unity_DeltaTime);
+                            Vector4 worldSpaceCameraPos = Shader.GetGlobalVector(HDShaderIDs._WorldSpaceCameraPos);
+                            Vector4 projectionParams = Shader.GetGlobalVector(HDShaderIDs._ProjectionParams);
+                            Vector4 screenParams = Shader.GetGlobalVector(HDShaderIDs._ScreenParams);
+                            Vector4 zbufferParams = Shader.GetGlobalVector(HDShaderIDs._ZBufferParams);
+                            Vector4 unity_OrthoParams = Shader.GetGlobalVector(HDShaderIDs.unity_OrthoParams);
+                            int envLightSkyEnabled = Shader.GetGlobalInt(HDShaderIDs._EnvLightSkyEnabled);
+                            float ambientOcclusionDirectLightStrenght = Shader.GetGlobalFloat(HDShaderIDs._AmbientOcclusionDirectLightStrenght);
-                            Vector4 time = Shader.GetGlobalVector("_Time");
-                            Vector4 sinTime = Shader.GetGlobalVector("_SinTime");
-                            Vector4 cosTime = Shader.GetGlobalVector("_CosTime");
-                            Vector4 unity_DeltaTime = Shader.GetGlobalVector("unity_DeltaTime");
-                            Vector4 worldSpaceCameraPos = Shader.GetGlobalVector("_WorldSpaceCameraPos");
-                            Vector4 projectionParams = Shader.GetGlobalVector("_ProjectionParams");
-                            Vector4 screenParams = Shader.GetGlobalVector("_ScreenParams");
-                            Vector4 zbufferParams = Shader.GetGlobalVector("_ZBufferParams");
-                            Vector4 unity_OrthoParams = Shader.GetGlobalVector("unity_OrthoParams");
-                            int envLightSkyEnabled = Shader.GetGlobalInt("_EnvLightSkyEnabled");
+                            int enableSSSAndTransmission = Shader.GetGlobalInt(HDShaderIDs._EnableSSSAndTransmission);
+                            int texturingModeFlags = Shader.GetGlobalInt(HDShaderIDs._TexturingModeFlags);
+                            int transmissionFlags = Shader.GetGlobalInt(HDShaderIDs._TransmissionFlags);
+                            Vector4[] thicknessRemaps = Shader.GetGlobalVectorArray(HDShaderIDs._ThicknessRemaps);
+                            Vector4[] shapeParams = Shader.GetGlobalVectorArray(HDShaderIDs._ShapeParams);
+                            Vector4[] transmissionTints = Shader.GetGlobalVectorArray(HDShaderIDs._TransmissionTints);
-                            int enableSSSAndTransmission = Shader.GetGlobalInt("_EnableSSSAndTransmission");
-                            int texturingModeFlags = Shader.GetGlobalInt("_TexturingModeFlags");
-                            int transmissionFlags = Shader.GetGlobalInt("_TransmissionFlags");
-                            Vector4[] thicknessRemaps = Shader.GetGlobalVectorArray("_ThicknessRemaps");
-                            Vector4[] shapeParams = Shader.GetGlobalVectorArray("_ShapeParams");
-                            Vector4[] transmissionTints = Shader.GetGlobalVectorArray("_TransmissionTints");
+                            Texture skyTexture = Shader.GetGlobalTexture(HDShaderIDs._SkyTexture);
 
                             for (int variant = 0; variant < numVariants; variant++)
                             {
                                 {
-                                    kernel = usingFptl ? s_shadeOpaqueIndirectFptlKernels[variant] : s_shadeOpaqueIndirectClusteredKernels[variant];
+                                    // Tag: SUPPORT_COMPUTE_CLUSTER_OPAQUE - Uncomment this if you want to do cluster opaque with compute shader (by default we support only fptl on opaque)
+                                    // kernel = usingFptl ? s_shadeOpaqueIndirectFptlKernels[variant] : s_shadeOpaqueIndirectClusteredKernels[variant];
+                                    kernel = s_shadeOpaqueIndirectFptlKernels[variant];
                                 }
                                 else
                                 {
 
                                 // Pass global parameters to compute shader
                                 // TODO: get rid of this by making global parameters visible to compute shaders
-                                PushGlobalParams(camera, cmd, shadeOpaqueShader, kernel);
-                                hdCamera.SetupComputeShader(shadeOpaqueShader, cmd);
+                                PushGlobalParams(camera, cmd, deferredComputeShader, kernel);
+                                hdCamera.SetupComputeShader(deferredComputeShader, cmd);
-                                cmd.SetComputeIntParam(shadeOpaqueShader, "_DebugViewMaterial", debugViewMaterial);
-                                cmd.SetComputeIntParam(shadeOpaqueShader, "_DebugLightingMode", debugLightingMode);
-                                cmd.SetComputeVectorParam(shadeOpaqueShader, "_DebugLightingAlbedo", debugLightingAlbedo);
-                                cmd.SetComputeVectorParam(shadeOpaqueShader, "_DebugLightingSmoothness", debugLightingSmoothness);
+                                cmd.SetComputeIntParam(deferredComputeShader, HDShaderIDs._DebugViewMaterial, debugViewMaterial);
+                                cmd.SetComputeIntParam(deferredComputeShader, HDShaderIDs._DebugLightingMode, debugLightingMode);
+                                cmd.SetComputeVectorParam(deferredComputeShader, HDShaderIDs._DebugLightingAlbedo, debugLightingAlbedo);
+                                cmd.SetComputeVectorParam(deferredComputeShader, HDShaderIDs._DebugLightingSmoothness, debugLightingSmoothness);
-                                cmd.SetComputeBufferParam(shadeOpaqueShader, kernel, "g_vLightListGlobal", bUseClusteredForDeferred ? s_PerVoxelLightLists : s_LightList);
+                                cmd.SetComputeBufferParam(deferredComputeShader, kernel, HDShaderIDs.g_vLightListGlobal, bUseClusteredForDeferred ? s_PerVoxelLightLists : s_LightList);
-                                cmd.SetComputeTextureParam(shadeOpaqueShader, kernel, "_MainDepthTexture", depthTexture);
-                                cmd.SetComputeTextureParam(shadeOpaqueShader, kernel, "_GBufferTexture0", gbufferTexture0);
-                                cmd.SetComputeTextureParam(shadeOpaqueShader, kernel, "_GBufferTexture1", gbufferTexture1);
-                                cmd.SetComputeTextureParam(shadeOpaqueShader, kernel, "_GBufferTexture2", gbufferTexture2);
-                                cmd.SetComputeTextureParam(shadeOpaqueShader, kernel, "_GBufferTexture3", gbufferTexture3);
-                                cmd.SetComputeTextureParam(shadeOpaqueShader, kernel, "_AmbientOcclusionTexture", ambientOcclusionTexture);
+                                cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs._MainDepthTexture, depthTexture);
+                                cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs._GBufferTexture0, HDShaderIDs._GBufferTexture0);
+                                cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs._GBufferTexture1, HDShaderIDs._GBufferTexture1);
+                                cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs._GBufferTexture2, HDShaderIDs._GBufferTexture2);
+                                cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs._GBufferTexture3, HDShaderIDs._GBufferTexture3);
+                                cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs._AmbientOcclusionTexture, HDShaderIDs._AmbientOcclusionTexture);
-                                cmd.SetComputeTextureParam(shadeOpaqueShader, kernel, "_LtcData", ltcData);
-                                cmd.SetComputeTextureParam(shadeOpaqueShader, kernel, "_PreIntegratedFGD", preIntegratedFGD);
-                                cmd.SetComputeTextureParam(shadeOpaqueShader, kernel, "_LtcGGXMatrix", ltcGGXMatrix);
-                                cmd.SetComputeTextureParam(shadeOpaqueShader, kernel, "_LtcDisneyDiffuseMatrix", ltcDisneyDiffuseMatrix);
-                                cmd.SetComputeTextureParam(shadeOpaqueShader, kernel, "_LtcMultiGGXFresnelDisneyDiffuse", ltcMultiGGXFresnelDisneyDiffuse);
+                                cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs._LtcData, ltcData);
+                                cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs._PreIntegratedFGD, preIntegratedFGD);
+                                cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs._LtcGGXMatrix, ltcGGXMatrix);
+                                cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs._LtcDisneyDiffuseMatrix, ltcDisneyDiffuseMatrix);
+                                cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs._LtcMultiGGXFresnelDisneyDiffuse, ltcMultiGGXFresnelDisneyDiffuse);
-                                cmd.SetComputeMatrixParam(shadeOpaqueShader, "g_mInvScrProjection", invScrProjection);
-                                cmd.SetComputeIntParam(shadeOpaqueShader, "_UseTileLightList", useTileLightList);
+                                cmd.SetComputeMatrixParam(deferredComputeShader, HDShaderIDs.g_mInvScrProjection, invScrProjection);
+                                cmd.SetComputeIntParam(deferredComputeShader, HDShaderIDs._UseTileLightList, useTileLightList);
-                                cmd.SetComputeVectorParam(shadeOpaqueShader, "_Time", time);
-                                cmd.SetComputeVectorParam(shadeOpaqueShader, "_SinTime", sinTime);
-                                cmd.SetComputeVectorParam(shadeOpaqueShader, "_CosTime", cosTime);
-                                cmd.SetComputeVectorParam(shadeOpaqueShader, "unity_DeltaTime", unity_DeltaTime);
-                                cmd.SetComputeVectorParam(shadeOpaqueShader, "_WorldSpaceCameraPos", worldSpaceCameraPos);
-                                cmd.SetComputeVectorParam(shadeOpaqueShader, "_ProjectionParams", projectionParams);
-                                cmd.SetComputeVectorParam(shadeOpaqueShader, "_ScreenParams", screenParams);
-                                cmd.SetComputeVectorParam(shadeOpaqueShader, "_ZBufferParams", zbufferParams);
-                                cmd.SetComputeVectorParam(shadeOpaqueShader, "unity_OrthoParams", unity_OrthoParams);
-                                cmd.SetComputeIntParam(shadeOpaqueShader, "_EnvLightSkyEnabled", envLightSkyEnabled);
+                                cmd.SetComputeVectorParam(deferredComputeShader, HDShaderIDs._Time, time);
+                                cmd.SetComputeVectorParam(deferredComputeShader, HDShaderIDs._SinTime, sinTime);
+                                cmd.SetComputeVectorParam(deferredComputeShader, HDShaderIDs._CosTime, cosTime);
+                                cmd.SetComputeVectorParam(deferredComputeShader, HDShaderIDs.unity_DeltaTime, unity_DeltaTime);
+                                cmd.SetComputeIntParam(deferredComputeShader, HDShaderIDs._EnvLightSkyEnabled, envLightSkyEnabled);
+                                cmd.SetComputeFloatParam(deferredComputeShader, HDShaderIDs._AmbientOcclusionDirectLightStrenght, ambientOcclusionDirectLightStrenght);
-                                Texture skyTexture = Shader.GetGlobalTexture("_SkyTexture");
-                                Texture IESArrayTexture = Shader.GetGlobalTexture("_IESArray");
-                                cmd.SetComputeTextureParam(shadeOpaqueShader, kernel, "_IESArray", IESArrayTexture ? IESArrayTexture : m_DefaultTexture2DArray);
-                                cmd.SetComputeTextureParam(shadeOpaqueShader, kernel, "_SkyTexture", skyTexture ? skyTexture : m_DefaultTexture2DArray);
+                                cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs._SkyTexture, skyTexture ? skyTexture : m_DefaultTexture2DArray);
-                                cmd.SetComputeIntParam(   shadeOpaqueShader, "_EnableSSSAndTransmission", enableSSSAndTransmission);
-                                cmd.SetComputeIntParam(   shadeOpaqueShader, "_TexturingModeFlags",       texturingModeFlags);
-                                cmd.SetComputeIntParam(   shadeOpaqueShader, "_TransmissionFlags",        transmissionFlags);
-                                cmd.SetComputeVectorArrayParam(shadeOpaqueShader, "_ThicknessRemaps",     thicknessRemaps);
+                                cmd.SetComputeIntParam(   deferredComputeShader, HDShaderIDs._EnableSSSAndTransmission, enableSSSAndTransmission);
+                                cmd.SetComputeIntParam(   deferredComputeShader, HDShaderIDs._TexturingModeFlags,       texturingModeFlags);
+                                cmd.SetComputeIntParam(   deferredComputeShader, HDShaderIDs._TransmissionFlags,        transmissionFlags);
+                                cmd.SetComputeVectorArrayParam(deferredComputeShader, HDShaderIDs._ThicknessRemaps,     thicknessRemaps);
-                                cmd.SetComputeVectorArrayParam(shadeOpaqueShader, "_ShapeParams",       shapeParams);
-                                cmd.SetComputeVectorArrayParam(shadeOpaqueShader, "_TransmissionTints", transmissionTints);
+                                cmd.SetComputeVectorArrayParam(deferredComputeShader, HDShaderIDs._ShapeParams,       shapeParams);
+                                cmd.SetComputeVectorArrayParam(deferredComputeShader, HDShaderIDs._TransmissionTints, transmissionTints);
-                                cmd.SetComputeTextureParam(shadeOpaqueShader, kernel, "specularLightingUAV", colorBuffers[0]);
-                                cmd.SetComputeTextureParam(shadeOpaqueShader, kernel, "diffuseLightingUAV",  colorBuffers[1]);
+                                cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs.specularLightingUAV, colorBuffers[0]);
+                                cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs.diffuseLightingUAV,  colorBuffers[1]);
-                                    cmd.SetComputeIntParam(shadeOpaqueShader, "g_TileListOffset", variant * numTiles);
-                                    cmd.SetComputeBufferParam(shadeOpaqueShader, kernel, "g_TileList", s_TileList);
-                                    cmd.DispatchCompute(shadeOpaqueShader, kernel, s_DispatchIndirectBuffer, (uint)variant * 3 * sizeof(uint));
+                                    cmd.SetComputeIntParam(deferredComputeShader, HDShaderIDs.g_TileListOffset, variant * numTiles);
+                                    cmd.SetComputeBufferParam(deferredComputeShader, kernel, HDShaderIDs.g_TileList, s_TileList);
+                                    cmd.DispatchCompute(deferredComputeShader, kernel, s_DispatchIndirectBuffer, (uint)variant * 3 * sizeof(uint));
-                                    cmd.DispatchCompute(shadeOpaqueShader, kernel, numTilesX, numTilesY, 1);
+                                    cmd.DispatchCompute(deferredComputeShader, kernel, numTilesX, numTilesY, 1);
                                 }
                             }
                         }
                                 // If SSS is disable, do lighting for both split lighting and no split lighting
                                 if (!debugDisplaySettings.renderingDebugSettings.enableSSSAndTransmission)
                                 {
-                                    m_DeferredAllMaterialSRT.SetInt("_StencilRef", (int)StencilLightingUsage.NoLighting);
-                                    m_DeferredAllMaterialSRT.SetInt("_StencilCmp", (int)CompareFunction.NotEqual);
+                                    m_DeferredAllMaterialSRT.SetInt(HDShaderIDs._StencilRef, (int)StencilLightingUsage.NoLighting);
+                                    m_DeferredAllMaterialSRT.SetInt(HDShaderIDs._StencilCmp, (int)CompareFunction.NotEqual);
-                                    m_DeferredAllMaterialSRT.SetInt("_StencilRef", (int)StencilLightingUsage.RegularLighting);
-                                    m_DeferredAllMaterialSRT.SetInt("_StencilCmp", (int)CompareFunction.Equal);
+                                    m_DeferredAllMaterialSRT.SetInt(HDShaderIDs._StencilRef, (int)StencilLightingUsage.RegularLighting);
+                                    m_DeferredAllMaterialSRT.SetInt(HDShaderIDs._StencilCmp, (int)CompareFunction.Equal);
                                 }
 
                                 Utilities.SelectKeyword(m_DeferredAllMaterialSRT, "USE_CLUSTERED_LIGHTLIST", "USE_FPTL_LIGHTLIST", bUseClusteredForDeferred);
                 }
                 else
                 {
-                    // Only opaques can use FPTL, transparents must use clustered!
+                    // Only opaques can use FPTL, transparent must use clustered!
                     bool useFptl = renderOpaque && usingFptl;
 
                     using (new Utilities.ProfilingSample(useFptl ? "Forward Tiled pass" : "Forward Clustered pass", cmd))
                         cmd.DisableShaderKeyword("LIGHTLOOP_SINGLE_PASS");
-                        cmd.SetGlobalFloat("_UseTileLightList", useFptl ? 1 : 0);      // leaving this as a dynamic toggle for now for forward opaques to keep shader variants down.
-                        cmd.SetGlobalBuffer("g_vLightListGlobal", useFptl ? s_LightList : s_PerVoxelLightLists);
+                        cmd.SetGlobalFloat(HDShaderIDs._UseTileLightList, useFptl ? 1 : 0);      // leaving this as a dynamic toggle for now for forward opaques to keep shader variants down.
+                        cmd.SetGlobalBuffer(HDShaderIDs.g_vLightListGlobal, useFptl ? s_LightList : s_PerVoxelLightLists);
                     }
                 }
             }

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/TilePass.cs.hlsl

 #define USE_LEFT_HAND_CAMERA_SPACE (1)
 #define TILE_SIZE_FPTL (16)
 #define TILE_SIZE_CLUSTERED (32)
-#define NUM_FEATURE_VARIANTS (26)
+#define NUM_FEATURE_VARIANTS (31)
 #define LIGHT_FEATURE_MASK_FLAGS (65280)
 #define MATERIAL_FEATURE_MASK_FLAGS (255)
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/TilePass.hlsl

-#if defined (LIGHTLOOP_TILE_DIRECT) || defined(LIGHTLOOP_TILE_ALL)
-#define PROCESS_DIRECTIONAL_LIGHT
-#define PROCESS_PUNCTUAL_LIGHT
-#define PROCESS_AREA_LIGHT
-#endif
-
-#if defined (LIGHTLOOP_TILE_INDIRECT) || defined(LIGHTLOOP_TILE_ALL)
-#define PROCESS_ENV_LIGHT
-#endif
-
 #include "TilePass.cs.hlsl"
 
 StructuredBuffer<uint> g_vLightListGlobal;      // don't support Buffer yet in unity
 StructuredBuffer<EnvLightData>         _EnvLightDatas;
 StructuredBuffer<ShadowData>           _ShadowDatas;
 
-// Use texture array for IES
-//TEXTURE2D_ARRAY(_IESArray);
-//SAMPLER2D(sampler_IESArray);
-
 // Used by directional and spot lights
 TEXTURE2D_ARRAY(_CookieTextures);
 SAMPLER2D(sampler_CookieTextures);
 TEXTURECUBE(_SkyTexture);
 SAMPLERCUBE(sampler_SkyTexture); // NOTE: Sampler could be share here with _EnvTextures. Don't know if the shader compiler will complain...
 
+TEXTURE2D(_AmbientOcclusionTexture);
+
 CBUFFER_START(UnityPerLightLoop)
 uint _DirectionalLightCount;
 uint _PunctualLightCount;
 
 int  _EnvLightSkyEnabled;         // TODO: make it a bool
+float _AmbientOcclusionDirectLightStrenght;
+
 CBUFFER_END
 
 struct LightLoopContext
 }
 
 //-----------------------------------------------------------------------------
-// IES sampling function
-// ----------------------------------------------------------------------------
-
-// sphericalTexCoord is theta and phi spherical coordinate
-//float4 SampleIES(LightLoopContext lightLoopContext, int index, float2 sphericalTexCoord, float lod)
-//{
-//    return SAMPLE_TEXTURE2D_ARRAY_LOD(_IESArray, sampler_IESArray, sphericalTexCoord, index, 0);
-//}
-
-//-----------------------------------------------------------------------------
 // Reflection proble / Sky sampling function
 // ----------------------------------------------------------------------------
 
         return SAMPLE_TEXTURECUBE_LOD(_SkyTexture, sampler_SkyTexture, texCoord, lod);
     }
 }
-
-//-----------------------------------------------------------------------------
-// AmbientOcclusion
-// ----------------------------------------------------------------------------
-
-TEXTURE2D(_AmbientOcclusionTexture);

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/TilePassLoop.hlsl

     return (_UseTileLightList ? ((value >> ((lightIndexPlusOne & 1) * DWORD_PER_TILE)) & 0xffff) : value);
 }
 
-#endif
+#endif // USE_FPTL_LIGHTLIST
+
+#else
+
+uint GetTileSize()
+{
+    return 1;
+}
+
+#endif // LIGHTLOOP_TILE_PASS
 
 // bakeDiffuseLighting is part of the prototype so a user is able to implement a "base pass" with GI and multipass direct light (aka old unity rendering path)
 void LightLoop( float3 V, PositionInputs posInput, PreLightData prelightData, BSDFData bsdfData, float3 bakeDiffuseLighting, uint featureFlags,
 
     uint i = 0; // Declare once to avoid the D3D11 compiler warning.
 
-#ifdef PROCESS_DIRECTIONAL_LIGHT
-    if(featureFlags & LIGHTFEATUREFLAGS_DIRECTIONAL)
+    if (featureFlags & LIGHTFEATUREFLAGS_DIRECTIONAL)
-            EvaluateBSDF_Directional(context, V, posInput, prelightData,
-                                     _DirectionalLightDatas[i], bsdfData,
+            EvaluateBSDF_Directional(context, V, posInput, prelightData, _DirectionalLightDatas[i], bsdfData,
                                      localDiffuseLighting, localSpecularLighting);
 
             diffuseLighting += localDiffuseLighting;
-#endif
-#ifdef PROCESS_PUNCTUAL_LIGHT
-    if(featureFlags & LIGHTFEATUREFLAGS_PUNCTUAL)
+    if (featureFlags & LIGHTFEATUREFLAGS_PUNCTUAL)
+        #ifdef LIGHTLOOP_TILE_PASS
+
         // TODO: Convert the for loop below to a while on each type as we know we are sorted!
         uint punctualLightStart;
         uint punctualLightCount;
             diffuseLighting += localDiffuseLighting;
             specularLighting += localSpecularLighting;
         }
+
+        #else
+
+        for (i = 0; i < _PunctualLightCount; ++i)
+        {
+            float3 localDiffuseLighting, localSpecularLighting;
+
+            EvaluateBSDF_Punctual(  context, V, posInput, prelightData, _LightDatas[i], bsdfData,
+                                    localDiffuseLighting, localSpecularLighting);
+
+            diffuseLighting += localDiffuseLighting;
+            specularLighting += localSpecularLighting;
+        }
+
+        #endif
-#endif
-#ifdef PROCESS_AREA_LIGHT
-    if(featureFlags & LIGHTFEATUREFLAGS_AREA)
+    if (featureFlags & LIGHTFEATUREFLAGS_AREA)
+        #ifdef LIGHTLOOP_TILE_PASS
+
         uint areaLightStart;
         uint areaLightCount;
         GetCountAndStart(posInput, LIGHTCATEGORY_AREA, areaLightStart, areaLightCount);
 
-        // !!!!!!!!!!!!!!
-        // COMPILER BEHAVIOR WARNING
+        // COMPILER BEHAVIOR WARNING!
+        // TODO: This is based on the current Lit.shader and can be different for any other way of implementing area lights, how to be generic and ensure performance ?
-        uint areaIndex = FetchIndex(areaLightStart, i);
-        while ( i < areaLightCount && _LightDatas[areaIndex].lightType == GPULIGHTTYPE_LINE)
+        if (areaLightCount > 0)
-            areaIndex = FetchIndex(areaLightStart, i);
-            EvaluateBSDF_Line(  context, V, posInput, prelightData, _LightDatas[areaIndex], bsdfData,
-                                localDiffuseLighting, localSpecularLighting);
+            uint areaIndex = FetchIndex(areaLightStart, 0);
+            uint lightType = _LightDatas[areaIndex].lightType;
+
+            while (i < areaLightCount && lightType == GPULIGHTTYPE_LINE)
+            {
+                EvaluateBSDF_Area(  context, V, posInput, prelightData, _LightDatas[areaIndex], bsdfData, GPULIGHTTYPE_LINE,
+                                    localDiffuseLighting, localSpecularLighting);
+
+                diffuseLighting += localDiffuseLighting;
+                specularLighting += localSpecularLighting;
+
+                i++;
+                areaIndex = i < areaLightCount ? FetchIndex(areaLightStart, i) : 0;
+                lightType = i < areaLightCount ? _LightDatas[areaIndex].lightType : 0xFF;
+            }
+
+            while (i < areaLightCount /* && lightType == GPULIGHTTYPE_RECT */) // Rectangle lights are the last area lights so no need to check type (for now)
+            {
+                EvaluateBSDF_Area(  context, V, posInput, prelightData, _LightDatas[areaIndex], bsdfData, GPULIGHTTYPE_RECTANGLE,
+                                    localDiffuseLighting, localSpecularLighting);
-            diffuseLighting += localDiffuseLighting;
-            specularLighting += localSpecularLighting;
+                diffuseLighting += localDiffuseLighting;
+                specularLighting += localSpecularLighting;
-            i++;
+                i++;
+                areaIndex = i < areaLightCount ? FetchIndex(areaLightStart, i) : 0;
+               // lightType = i < areaLightCount ? _LightDatas[areaIndex].lightType : 0xFF;
+            }
-        while (i < areaLightCount) // Rectangle lights are the last area lights so no need to check type
+        #else
+
+        for (; i < _PunctualLightCount + _AreaLightCount; ++i)
-            areaIndex = FetchIndex(areaLightStart, i);
-            EvaluateBSDF_Area(  context, V, posInput, prelightData, _LightDatas[areaIndex], bsdfData,
+            float3 localDiffuseLighting, localSpecularLighting;
+
+            EvaluateBSDF_Area(  context, V, posInput, prelightData, _LightDatas[i], bsdfData, _LightDatas[i].lightType,
-
-            i++;
-    }
-#endif
-
-#ifdef PROCESS_ENV_LIGHT
-    float3 iblDiffuseLighting = float3(0.0, 0.0, 0.0);
-    float3 iblSpecularLighting = float3(0.0, 0.0, 0.0);
-    // Only apply sky IBL if the sky texture is available.
-    if(featureFlags & LIGHTFEATUREFLAGS_SKY)
-    {
-        if(_EnvLightSkyEnabled)
-        {
-            float3 localDiffuseLighting, localSpecularLighting;
-            float2 weight;
-            // The sky is a single cubemap texture separate from the reflection probe texture array (different resolution and compression)
-            context.sampleReflection = SINGLE_PASS_CONTEXT_SAMPLE_SKY;
-            EnvLightData envLightSky = InitSkyEnvLightData(0); // The sky data are generated on the fly so the compiler can optimize the code
-            EvaluateBSDF_Env(context, V, posInput, prelightData, envLightSky, bsdfData, localDiffuseLighting, localSpecularLighting, weight);
-            iblDiffuseLighting = lerp(iblDiffuseLighting, localDiffuseLighting, weight.x); // Should be remove by the compiler if it is smart as all is constant 0
-            iblSpecularLighting = lerp(iblSpecularLighting, localSpecularLighting, weight.y);
-        }
+        #endif
+    float3 iblDiffuseLighting  = float3(0.0, 0.0, 0.0);
+    float3 iblSpecularLighting = float3(0.0, 0.0, 0.0);
+    float  totalIblWeight      = 0; // Max: 1
+    // Reflection probes are sorted by volume (in the increasing order).
+    #ifdef LIGHTLOOP_TILE_PASS
+    #else
+        uint envLightCount = _EnvLightCount;
+    #endif
-        for(i = 0; i < envLightCount; ++i)
+        for(i = 0; i < envLightCount && totalIblWeight < 1.0; ++i)
+        #ifdef LIGHTLOOP_TILE_PASS
+            uint envLightIndex = FetchIndex(envLightStart, i);
+        #else
+            uint envLightIndex = i;
+        #endif
+
-            EvaluateBSDF_Env(context, V, posInput, prelightData, _EnvLightDatas[FetchIndex(envLightStart, i)], bsdfData, localDiffuseLighting, localSpecularLighting, weight);
+            EvaluateBSDF_Env(context, V, posInput, prelightData, _EnvLightDatas[envLightIndex], bsdfData, localDiffuseLighting, localSpecularLighting, weight);
+
+            // IBL weights should not exceed 1.
+            float accumulatedWeight = totalIblWeight + weight.y;
+            totalIblWeight          = saturate(accumulatedWeight);
+            weight.y               -= saturate(accumulatedWeight - totalIblWeight);
+
-
-    diffuseLighting += iblDiffuseLighting;
-    specularLighting += iblSpecularLighting;
-#endif
-
-    // TODO: currently apply GI at the same time as reflection
-#ifdef PROCESS_ENV_LIGHT
-    // Add indirect diffuse + emissive (if any)
-    diffuseLighting += bakeDiffuseLighting * context.ambientOcclusion;
-#endif
-
-    ApplyDebug(context, posInput.positionWS, diffuseLighting, specularLighting);
-}
-
-#else // LIGHTLOOP_SINGLE_PASS
-
-uint GetTileSize()
-{
-    return 1;
-}
-
-
-// bakeDiffuseLighting is part of the prototype so a user is able to implement a "base pass" with GI and multipass direct light (aka old unity rendering path)
-void LightLoop( float3 V, PositionInputs posInput, PreLightData prelightData, BSDFData bsdfData, float3 bakeDiffuseLighting, uint featureFlag,
-                out float3 diffuseLighting,
-                out float3 specularLighting)
-{
-    LightLoopContext context;
-    // Note: When we ImageLoad outside of texture size, the value returned by Load is 0 (Note: On Metal maybe it clamp to value of texture which is also fine)
-    // We use this property to have a neutral value for AO that doesn't consume a sampler and work also with compute shader (i.e use ImageLoad)
-    // We store inverse AO so neutral is black. So either we sample inside or outside the texture it return 0 in case of neutral
-    context.ambientOcclusion = 1.0 - LOAD_TEXTURE2D(_AmbientOcclusionTexture, posInput.unPositionSS).x;
-    context.sampleShadow = 0;
-    context.sampleReflection = 0;
-    context.shadowContext = InitShadowContext();
-
-    diffuseLighting = float3(0.0, 0.0, 0.0);
-    specularLighting = float3(0.0, 0.0, 0.0);
-
-    uint i = 0; // Declare once to avoid the D3D11 compiler warning.
-
-    for (i = 0; i < _DirectionalLightCount; ++i)
-    {
-        float3 localDiffuseLighting, localSpecularLighting;
-
-        EvaluateBSDF_Directional(context, V, posInput, prelightData,
-                                 _DirectionalLightDatas[i], bsdfData,
-                                 localDiffuseLighting, localSpecularLighting);
-
-        diffuseLighting += localDiffuseLighting;
-        specularLighting += localSpecularLighting;
-    }
-
-    for (i = 0; i < _PunctualLightCount; ++i)
-    {
-        float3 localDiffuseLighting, localSpecularLighting;
-
-        EvaluateBSDF_Punctual(  context, V, posInput, prelightData, _LightDatas[i], bsdfData,
-                                localDiffuseLighting, localSpecularLighting);
-
-        diffuseLighting += localDiffuseLighting;
-        specularLighting += localSpecularLighting;
-    }
-
-    for (; i < _PunctualLightCount + _AreaLightCount; ++i)
+    if(featureFlags & LIGHTFEATUREFLAGS_SKY)
-        float3 localDiffuseLighting, localSpecularLighting;
-
-        if (_LightDatas[i].lightType == GPULIGHTTYPE_LINE)
+        // Only apply the sky IBL if the sky texture is available, and if we haven't yet accumulated enough IBL lighting.
+        if(_EnvLightSkyEnabled && totalIblWeight < 1.0)
-            EvaluateBSDF_Line(  context, V, posInput, prelightData, _LightDatas[i], bsdfData,
-                                localDiffuseLighting, localSpecularLighting);
-        }
-        else
-        {
-            EvaluateBSDF_Area(  context, V, posInput, prelightData, _LightDatas[i], bsdfData,
-                                localDiffuseLighting, localSpecularLighting);
-        }
+            float3 localDiffuseLighting, localSpecularLighting;
+            float2 weight;
-        diffuseLighting += localDiffuseLighting;
-        specularLighting += localSpecularLighting;
-    }
+            // The sky is a single cubemap texture separate from the reflection probe texture array (different resolution and compression)
+            context.sampleReflection = SINGLE_PASS_CONTEXT_SAMPLE_SKY;
+            EnvLightData envLightSky = InitSkyEnvLightData(0); // The sky data are generated on the fly so the compiler can optimize the code
+            EvaluateBSDF_Env(context, V, posInput, prelightData, envLightSky, bsdfData, localDiffuseLighting, localSpecularLighting, weight);
-    // TODO: Check the reflection hierarchy, for the current system (matching legacy unity) we must sort from bigger solid angle to lower (lower override bigger). So begging by sky
-    // TODO: Change the way it is done by reversing the order, from smaller solid angle to bigger, so we can early out when the weight is 1.
-    float3 iblDiffuseLighting = float3(0.0, 0.0, 0.0);
-    float3 iblSpecularLighting = float3(0.0, 0.0, 0.0);
+            // IBL weights should not exceed 1.
+            float accumulatedWeight = totalIblWeight + weight.y;
+            totalIblWeight          = 1.0;
+            weight.y               -= saturate(accumulatedWeight - totalIblWeight);
-    // Only apply sky IBL if the sky texture is available.
-    if (_EnvLightSkyEnabled)
-    {
-        float3 localDiffuseLighting, localSpecularLighting;
-        float2 weight;
-        // The sky is a single cubemap texture separate from the reflection probe texture array (different resolution and compression)
-        context.sampleReflection = SINGLE_PASS_CONTEXT_SAMPLE_SKY;
-        EnvLightData envLightSky = InitSkyEnvLightData(0); // The sky data are generated on the fly so the compiler can optimize the code
-        EvaluateBSDF_Env(context, V, posInput, prelightData, envLightSky, bsdfData, localDiffuseLighting, localSpecularLighting, weight);
-        iblDiffuseLighting = lerp(iblDiffuseLighting, localDiffuseLighting, weight.x); // Should be remove by the compiler if it is smart as all is constant 0
-        iblSpecularLighting = lerp(iblSpecularLighting, localSpecularLighting, weight.y);
+            iblDiffuseLighting = lerp(iblDiffuseLighting, localDiffuseLighting, weight.x); // Should be remove by the compiler if it is smart as all is constant 0
+            iblSpecularLighting = lerp(iblSpecularLighting, localSpecularLighting, weight.y);
+        }
-    for (i = 0; i < _EnvLightCount; ++i)
-    {
-        float3 localDiffuseLighting, localSpecularLighting;
-        float2 weight;
-        context.sampleReflection = SINGLE_PASS_CONTEXT_SAMPLE_REFLECTION_PROBES;
-        EvaluateBSDF_Env(context, V, posInput, prelightData, _EnvLightDatas[i], bsdfData, localDiffuseLighting, localSpecularLighting, weight);
-        iblDiffuseLighting = lerp(iblDiffuseLighting, localDiffuseLighting, weight.x); // Should be remove by the compiler if it is smart as all is constant 0
-        iblSpecularLighting = lerp(iblSpecularLighting, localSpecularLighting, weight.y);
-    }
+    // Apply ambient occlusion on direct lighting based on strenght factor
+    diffuseLighting *= lerp(1.0, context.ambientOcclusion, _AmbientOcclusionDirectLightStrenght);
-    // Add indirect diffuse + emissive (if any)
+    // Apply GI at the same time as reflection
+    // Add indirect diffuse + emissive (if any) - Ambient occlusion is multiply by emissive which is wrong but not a big deal
-
-#endif

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/materialflags.compute

 #pragma kernel MaterialFlagsGen_Write		MATERIALFLAGSGEN=MaterialFlagsGen_Write
 #pragma kernel MaterialFlagsGen_Or			MATERIALFLAGSGEN=MaterialFlagsGen_Or		USE_OR
 
-//#pragma #pragma enable_d3d11_debug_symbols
+// #pragma enable_d3d11_debug_symbols
 
 #include "../../../ShaderLibrary/common.hlsl"
 #include "ShaderBase.hlsl"
 #include "../../Material/Material.hlsl" // This includes Material.hlsl
+#include "../../Lighting/LightDefinition.cs.hlsl"
 
 #define USE_MATERIAL_FEATURE_FLAGS
 #define NR_THREADS	64
 uint g_BaseFeatureFlags;
 CBUFFER_END
 
-Texture2D g_depth_tex : register( t0 );
-
+TEXTURE2D(_StencilTexture);               // DXGI_FORMAT_R8_UINT is not supported by Unity
 DECLARE_GBUFFER_TEXTURE(_GBufferTexture);
 
 [numthreads(NR_THREADS, 1, 1)]
 		int idx = i * NR_THREADS + threadID;
 		uint2 uCrd = min( uint2(viTilLL.x + (idx & 0xf), viTilLL.y + (idx >> 4)), uint2(iWidth - 1, iHeight - 1));
 
-		if (FetchDepth(g_depth_tex, uCrd) < VIEWPORT_SCALE_Z) // This test is we are the sky/background or not
+		if (UnpackByte(LOAD_TEXTURE2D(_StencilTexture, uCrd).r) != STENCILLIGHTINGUSAGE_NO_LIGHTING) // This test is we are the sky/background or not
 		{
 			PositionInputs posInput = GetPositionInput(uCrd, invScreenSize);
 			FETCH_GBUFFER(gbuffer, _GBufferTexture, posInput.unPositionSS);

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/LayeredLit/LayeredLit.shader

 
     #include "../../../ShaderLibrary/common.hlsl"
     #include "../../../ShaderLibrary/Wind.hlsl"
-    #include "../../ShaderConfig.cs.hlsl"
     #include "../../ShaderPass/FragInputs.hlsl"
     #include "../../ShaderPass/ShaderPass.cs.hlsl"
 

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

     #include "../../../ShaderLibrary/common.hlsl"
     #include "../../../ShaderLibrary/Wind.hlsl"
     #include "../../../ShaderLibrary/tessellation.hlsl"
-    #include "../../ShaderConfig.cs.hlsl"
     #include "../../ShaderPass/FragInputs.hlsl"
     #include "../../ShaderPass/ShaderPass.cs.hlsl"
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.hlsl

     /*  4 */ LIGHT_FEATURE_MASK_FLAGS | MATERIALFEATUREFLAGS_LIT_STANDARD,
 
     // SSS
-    // SSS is a superset of material standard. With foliage or crowd SSS and standard can overlap a lot, better to have a dedicated combination
-    /*  5 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_PUNCTUAL | MATERIALFEATUREFLAGS_LIT_SSS | MATERIALFEATUREFLAGS_LIT_STANDARD,
-    /*  6 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_AREA | MATERIALFEATUREFLAGS_LIT_SSS | MATERIALFEATUREFLAGS_LIT_STANDARD,
-    /*  7 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_ENV | MATERIALFEATUREFLAGS_LIT_SSS | MATERIALFEATUREFLAGS_LIT_STANDARD,
-    /*  8 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_PUNCTUAL | LIGHTFEATUREFLAGS_ENV | MATERIALFEATUREFLAGS_LIT_SSS | MATERIALFEATUREFLAGS_LIT_STANDARD,
+    /*  5 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_PUNCTUAL | MATERIALFEATUREFLAGS_LIT_SSS,
+    /*  6 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_AREA | MATERIALFEATUREFLAGS_LIT_SSS,
+    /*  7 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_ENV | MATERIALFEATUREFLAGS_LIT_SSS,
+    /*  8 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_PUNCTUAL | LIGHTFEATUREFLAGS_ENV | MATERIALFEATUREFLAGS_LIT_SSS,
     /*  9 */ LIGHT_FEATURE_MASK_FLAGS | MATERIALFEATUREFLAGS_LIT_SSS,
 
     // Specular/Aniso
     /* 13 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_PUNCTUAL | LIGHTFEATUREFLAGS_ENV | MATERIALFEATUREFLAGS_LIT_ANISO,
     /* 14 */ LIGHT_FEATURE_MASK_FLAGS | MATERIALFEATUREFLAGS_LIT_ANISO,
 
+    // SSS is a superset of material standard. With foliage or crowd SSS and standard can overlap a lot, better to have a dedicated combination
+    /* 15 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_PUNCTUAL | MATERIALFEATUREFLAGS_LIT_SSS | MATERIALFEATUREFLAGS_LIT_STANDARD,
+    /* 16 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_AREA | MATERIALFEATUREFLAGS_LIT_SSS | MATERIALFEATUREFLAGS_LIT_STANDARD,
+    /* 17 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_ENV | MATERIALFEATUREFLAGS_LIT_SSS | MATERIALFEATUREFLAGS_LIT_STANDARD,
+    /* 18 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_PUNCTUAL | LIGHTFEATUREFLAGS_ENV | MATERIALFEATUREFLAGS_LIT_SSS | MATERIALFEATUREFLAGS_LIT_STANDARD,
+    /* 19 */ LIGHT_FEATURE_MASK_FLAGS | MATERIALFEATUREFLAGS_LIT_SSS,
+
-    /* 15 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_PUNCTUAL | MATERIALFEATUREFLAGS_LIT_UNUSED0,
-    /* 16 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_AREA | MATERIALFEATUREFLAGS_LIT_UNUSED0,
-    /* 17 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_ENV | MATERIALFEATUREFLAGS_LIT_UNUSED0,
-    /* 18 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_PUNCTUAL | LIGHTFEATUREFLAGS_ENV | MATERIALFEATUREFLAGS_LIT_UNUSED0,
-    /* 19 */ LIGHT_FEATURE_MASK_FLAGS | MATERIALFEATUREFLAGS_LIT_UNUSED0,
+    /* 20 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_PUNCTUAL | MATERIALFEATUREFLAGS_LIT_UNUSED0,
+    /* 21 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_AREA | MATERIALFEATUREFLAGS_LIT_UNUSED0,
+    /* 22 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_ENV | MATERIALFEATUREFLAGS_LIT_UNUSED0,
+    /* 23 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_PUNCTUAL | LIGHTFEATUREFLAGS_ENV | MATERIALFEATUREFLAGS_LIT_UNUSED0,
+    /* 24 */ LIGHT_FEATURE_MASK_FLAGS | MATERIALFEATUREFLAGS_LIT_UNUSED0,
-    /* 20 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_PUNCTUAL | MATERIALFEATUREFLAGS_LIT_UNUSED1,
-    /* 21 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_AREA | MATERIALFEATUREFLAGS_LIT_UNUSED1,
-    /* 22 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_ENV | MATERIALFEATUREFLAGS_LIT_UNUSED1,
-    /* 23 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_PUNCTUAL | LIGHTFEATUREFLAGS_ENV | MATERIALFEATUREFLAGS_LIT_UNUSED1,
-    /* 24 */ LIGHT_FEATURE_MASK_FLAGS | MATERIALFEATUREFLAGS_LIT_UNUSED1,
+    /* 25 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_PUNCTUAL | MATERIALFEATUREFLAGS_LIT_UNUSED1,
+    /* 26 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_AREA | MATERIALFEATUREFLAGS_LIT_UNUSED1,
+    /* 27 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_ENV | MATERIALFEATUREFLAGS_LIT_UNUSED1,
+    /* 28 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_PUNCTUAL | LIGHTFEATUREFLAGS_ENV | MATERIALFEATUREFLAGS_LIT_UNUSED1,
+    /* 29 */ LIGHT_FEATURE_MASK_FLAGS | MATERIALFEATUREFLAGS_LIT_UNUSED1,
-    /* 25 */ LIGHT_FEATURE_MASK_FLAGS | MATERIAL_FEATURE_MASK_FLAGS, // Catch all case with MATERIAL_FEATURE_MASK_FLAGS is needed in case we disable material classification
+    /* 30 */ LIGHT_FEATURE_MASK_FLAGS | MATERIAL_FEATURE_MASK_FLAGS, // Catch all case with MATERIAL_FEATURE_MASK_FLAGS is needed in case we disable material classification
 };
 
 uint FeatureFlagsToTileVariant(uint featureFlags)
 #endif
 }
 
-void ApplyDebugToBSDFData(inout BSDFData bsdfData)
+void ApplyDebugToSurfaceData(inout SurfaceData surfaceData)
 {
 #ifdef DEBUG_DISPLAY
     if (_DebugLightingMode == DEBUGLIGHTINGMODE_SPECULAR_LIGHTING)
 
         if (overrideSmoothness)
         {
-            bsdfData.perceptualRoughness = PerceptualSmoothnessToPerceptualRoughness(overrideSmoothnessValue);
-            bsdfData.roughness = PerceptualRoughnessToRoughness(bsdfData.perceptualRoughness);
+            surfaceData.perceptualSmoothness = overrideSmoothnessValue;
-        bsdfData.diffuseColor = _DebugLightingAlbedo.xyz;
+        surfaceData.baseColor = _DebugLightingAlbedo.xyz;
     }
 #endif
 }
 
     bool performPostScatterTexturing = IsBitSet(_TexturingModeFlags, subsurfaceProfile);
 
+    bool enableSssAndTransmission = true;
+
-    if (0)
-#else
-    if (_EnableSSSAndTransmission != 0) // If we globally disable SSS effect, don't modify diffuseColor
+    enableSssAndTransmission = false;
+#elif (SSS_PASS == 0)
+    enableSssAndTransmission = _EnableSSSAndTransmission != 0;
+
+    if (enableSssAndTransmission) // If we globally disable SSS effect, don't modify diffuseColor
     {
         // We modify the albedo here as this code is used by all lighting (including light maps and GI).
         if (performPostScatterTexturing)
 
 BSDFData ConvertSurfaceDataToBSDFData(SurfaceData surfaceData)
 {
+    ApplyDebugToSurfaceData(surfaceData);
+
     BSDFData bsdfData;
     ZERO_INITIALIZE(BSDFData, bsdfData);
 
     {
         FillMaterialIdSSSData(surfaceData.baseColor, surfaceData.subsurfaceProfile, surfaceData.subsurfaceRadius, surfaceData.thickness, bsdfData);
     }
-
-    ApplyDebugToBSDFData(bsdfData);
 
     return bsdfData;
 }
     float4 outGBuffer0, outGBuffer1, outGBuffer2, outGBuffer3;
     #endif
 
+    ApplyDebugToSurfaceData(surfaceData);
+
     // RT0 - 8:8:8:8 sRGB
     outGBuffer0 = float4(surfaceData.baseColor, surfaceData.specularOcclusion);
 
         outGBuffer1.a = PackMaterialId(MATERIALID_LIT_STANDARD); // We save 1bit in gbuffer1 and use aniso value instead to detect we are aniso
         // Encode tangent on 16bit with oct compression
         float2 octTangentWS = PackNormalOctEncode(surfaceData.tangentWS);
-        outGBuffer2 = float4(octTangentWS * 0.5 + 0.5, surfaceData.anisotropy, PackFloatInt8bit(surfaceData.metallic, surfaceData.specular, 4.0));
+        // To be recognize as anisotropic material, we need to have anisotropy > 0 (Else artits can be confuse to not have anisotropic material in material classification), thus the max
+        outGBuffer2 = float4(octTangentWS * 0.5 + 0.5, max(surfaceData.anisotropy, 1.5 / 255.0), PackFloatInt8bit(surfaceData.metallic, surfaceData.specular, 4.0));
     }
     else if (surfaceData.materialId == MATERIALID_LIT_SSS)
     {
                             (packedGBuffer1 & 0x0000FFFF),
                             (packedGBuffer1 & 0xFFFF0000) >> 16);
 
-    uint packedGBuffer3 = PackR11G11B10f(outGBuffer3.xyz);
+    uint packedGBuffer3 = PackToR11G11B10f(outGBuffer3.xyz);
 
     outGBufferU1 = uint4(   PackFloatToUInt(outGBuffer2.x, 8, 0)  | PackFloatToUInt(outGBuffer2.y, 8, 8),
                             PackFloatToUInt(outGBuffer2.z, 8, 0)  | PackFloatToUInt(outGBuffer2.w, 8, 8),
     inGBuffer2.w = UnpackUIntToFloat(inGBufferU1.y, 8, 8);
 
     uint packedGBuffer3 = inGBufferU1.z | inGBufferU1.w << 16;
-    inGBuffer3.xyz = UnpackR11G11B10f(packedGBuffer1);
+    inGBuffer3.xyz = UnpackFromR11G11B10f(packedGBuffer1);
     inGBuffer3.w = 0.0;
 #endif
 
                 bsdfData.diffuseColor = baseColor;
                 bsdfData.fresnel0 = inGBuffer2.rgb;
             }
-            else if (anisotropy > 0)
+            else if (anisotropy > 0.0)
             {
                 bsdfData.materialId = MATERIALID_LIT_ANISO;
                 FillMaterialIdStandardData(baseColor, specular, metallic, bsdfData);
     }
 
     bakeDiffuseLighting = inGBuffer3.rgb;
-
-    ApplyDebugToBSDFData(bsdfData);
 }
 
 uint MaterialFeatureFlagsFromGBuffer(
 
 // #define ELLIPSOIDAL_ATTENUATION
 
-void EvaluateBSDF_Area(LightLoopContext lightLoopContext,
-                       float3 V, PositionInputs posInput,
-                       PreLightData preLightData, LightData lightData, BSDFData bsdfData,
-                       out float3 diffuseLighting, out float3 specularLighting)
+void EvaluateBSDF_Rect( LightLoopContext lightLoopContext,
+                        float3 V, PositionInputs posInput,
+                        PreLightData preLightData, LightData lightData, BSDFData bsdfData,
+                        out float3 diffuseLighting, out float3 specularLighting)
 {
     float3 positionWS = posInput.positionWS;
 
         specularLighting = fresnelTerm * lightData.color * ltcValue;
     }
 #endif // LIT_DISPLAY_REFERENCE_AREA
+}
+
+void EvaluateBSDF_Area(LightLoopContext lightLoopContext,
+    float3 V, PositionInputs posInput,
+    PreLightData preLightData, LightData lightData, BSDFData bsdfData, int GPULightType,
+    out float3 diffuseLighting, out float3 specularLighting)
+{
+    if (GPULightType == GPULIGHTTYPE_LINE)
+    {
+        EvaluateBSDF_Line(lightLoopContext, V, posInput, preLightData, lightData, bsdfData, diffuseLighting, specularLighting);
+    }
+    else
+    {
+        EvaluateBSDF_Rect(lightLoopContext, V, posInput, preLightData, lightData, bsdfData, diffuseLighting, specularLighting);
+    }
 }
 
 //-----------------------------------------------------------------------------

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.shader

 
     #include "../../../ShaderLibrary/common.hlsl"
     #include "../../../ShaderLibrary/Wind.hlsl"
-    #include "../../ShaderConfig.cs.hlsl"
     #include "../../ShaderPass/FragInputs.hlsl"
     #include "../../ShaderPass/ShaderPass.cs.hlsl"
 

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

 void GetSurfaceAndBuiltinData(FragInputs input, float3 V, inout PositionInputs posInput, out SurfaceData surfaceData, out BuiltinData builtinData)
 {
 #ifdef LOD_FADE_CROSSFADE // enable dithering LOD transition if user select CrossFade transition in LOD group
-    LODDitheringTransition(posInput.unPositionSS, unity_LODFade.y); // Note that we pass the quantized value of LOD fade
+    LODDitheringTransition(posInput.unPositionSS, unity_LODFade.x);
 #endif
 
     ApplyDoubleSidedFlipOrMirror(input); // Apply double sided flip on the vertex normal
 void GetSurfaceAndBuiltinData(FragInputs input, float3 V, inout PositionInputs posInput, out SurfaceData surfaceData, out BuiltinData builtinData)
 {
 #ifdef LOD_FADE_CROSSFADE // enable dithering LOD transition if user select CrossFade transition in LOD group
-    LODDitheringTransition(posInput.unPositionSS, unity_LODFade.y); // Note that we pass the quantized value of LOD fade
+    LODDitheringTransition(posInput.unPositionSS, unity_LODFade.x);
 #endif
 
     ApplyDoubleSidedFlipOrMirror(input); // Apply double sided flip on the vertex normal

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

     #include "../../../ShaderLibrary/common.hlsl"
     #include "../../../ShaderLibrary/Wind.hlsl"
     #include "../../../ShaderLibrary/tessellation.hlsl"
-    #include "../../ShaderConfig.cs.hlsl"
     #include "../../ShaderPass/FragInputs.hlsl"
     #include "../../ShaderPass/ShaderPass.cs.hlsl"
 

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

 Shader "Hidden/HDRenderPipeline/CopyStencilBuffer"
 {
+    Properties
+    {
+        [HideInInspector] _StencilRef("_StencilRef", Int) = 1
+    }
+
     SubShader
     {
         Pass
-                Ref  1 // StencilLightingUsage.SplitLighting
+                Ref  [_StencilRef]
                 Comp Equal
                 Pass Keep
             }
             HLSLPROGRAM
             #pragma target 4.5
             #pragma only_renderers d3d11 ps4 metal // TEMP: until we go further in dev
+            #pragma multi_compile _ EXPORT_HTILE
-            #include "../../../../ShaderLibrary/Common.hlsl"
-            #include "../../../ShaderConfig.cs.hlsl"
+            #include "../../../../ShaderLibrary/Packing.hlsl"
+
+            int _StencilRef;
+            RW_TEXTURE2D(float, _HTile); // DXGI_FORMAT_R8_UINT is not supported by Unity
 
             struct Attributes
             {
                 return output;
             }
 
-            // Should use HiS and therefore be faster than a GPU memcpy().
+            // Force the stencil test before the UAV write.
+            [earlydepthstencil]
-                return float4(STENCILLIGHTINGUSAGE_SPLIT_LIGHTING, 0, 0, 0);
+                uint2 positionSS = (uint2)input.positionCS.xy;
+
+                #ifdef EXPORT_HTILE
+                    // There's no need for atomics as we are always writing the same value.
+                    // Note: the GCN tile size is 8x8 pixels.
+                    _HTile[positionSS / 8] = _StencilRef;
+                #endif
+
+                return PackByte(_StencilRef);
             }
             ENDHLSL
         }

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

-Shader "Hidden/HDRenderPipeline/CombineSubsurfaceScattering"
+Shader "Hidden/HDRenderPipeline/SubsurfaceScattering"
-    // Old SSS Model >>>
-    // <<< Old SSS Model
 
     SubShader
     {
             Cull   Off
             ZTest  Always
             ZWrite Off
-            // Old SSS Model >>>
-            // <<< Old SSS Model
 
             HLSLPROGRAM
             #pragma target 4.5
             #pragma vertex Vert
             #pragma fragment Frag
 
-            // Old SSS Model >>>
-            #pragma multi_compile SSS_MODEL_BASIC SSS_MODEL_DISNEY
-            // <<< Old SSS Model
-
-            // Tweak parameters for the Disney SSS below.
-            #define SSS_BILATERAL_FILTER  1
-            #define SSS_USE_TANGENT_PLANE 0
-            #define SSS_CLAMP_ARTIFACT    0
-            #define SSS_DEBUG_LOD         0
-            #define SSS_DEBUG_NORMAL_VS   0
 
             // Do not modify these.
             #define SSS_PASS              1
             //-------------------------------------------------------------------------------------
 
             #include "../../../../ShaderLibrary/Common.hlsl"
-            #include "../../../ShaderConfig.cs.hlsl"
             #include "../../../ShaderVariables.hlsl"
             #define UNITY_MATERIAL_LIT // Needs to be defined before including Material.hlsl
             #include "../../../Material/Material.hlsl"
             //-------------------------------------------------------------------------------------
 
-
-            float  _WorldScales[SSS_N_PROFILES];                                         // Size of the world unit in meters
-        #ifdef SSS_MODEL_DISNEY
-            float  _FilterKernelsNearField[SSS_N_PROFILES][SSS_N_SAMPLES_NEAR_FIELD][2]; // 0 = radius, 1 = reciprocal of the PDF
-            float  _FilterKernelsFarField[SSS_N_PROFILES][SSS_N_SAMPLES_FAR_FIELD][2];   // 0 = radius, 1 = reciprocal of the PDF
-        #else
-            float4 _FilterKernelsBasic[SSS_N_PROFILES][SSS_BASIC_N_SAMPLES];             // RGB = weights, A = radial distance
-            float4 _HalfRcpWeightedVariances[SSS_BASIC_N_SAMPLES];                       // RGB for chromatic, A for achromatic
-        #endif
+            float4 _WorldScales[SSS_N_PROFILES];                             // Size of the world unit in meters (only the X component is used)
+            float4 _FilterKernelsBasic[SSS_N_PROFILES][SSS_BASIC_N_SAMPLES]; // RGB = weights, A = radial distance
+            float4 _HalfRcpWeightedVariances[SSS_BASIC_N_SAMPLES];           // RGB for chromatic, A for achromatic
 
             TEXTURE2D(_IrradianceSource);             // Includes transmitted light
             DECLARE_GBUFFER_TEXTURE(_GBufferTexture); // Contains the albedo and SSS parameters
             //-------------------------------------------------------------------------------------
 
-            // Computes the value of the integrand over a disk: (2 * PI * r) * KernelVal().
-            // N.b.: the returned value is multiplied by 4. It is irrelevant due to weight renormalization.
-            float3 KernelValCircle(float r, float3 S)
-            {
-                float3 expOneThird = exp(((-1.0 / 3.0) * r) * S);
-                return /* 0.25 * */ S * (expOneThird + expOneThird * expOneThird * expOneThird);
-            }
-
-            // Computes F(r)/P(r), s.t. r = sqrt(a^2 + b^2).
-            // Rescaling of the PDF is handled by 'totalWeight'.
-            float3 ComputeBilateralWeight(float a2, float b, float mmPerUnit, float3 S, float rcpPdf)
-            {
-            #if (SSS_BILATERAL_FILTER == 0)
-                b = 0;
-            #endif
-
-            #if SSS_USE_TANGENT_PLANE
-                // Both 'a2' and 'b2' require unit conversion.
-                float r = sqrt(a2 + b * b) * mmPerUnit;
-            #else
-                // Only 'b2' requires unit conversion.
-                float r = sqrt(a2 + (b * mmPerUnit) * (b * mmPerUnit));
-            #endif
-
-            #if SSS_CLAMP_ARTIFACT
-                return saturate(KernelValCircle(r, S) * rcpPdf);
-            #else
-                return KernelValCircle(r, S) * rcpPdf;
-            #endif
-            }
-
-            #define SSS_ITER(i, n, kernel, profileID, shapeParam, centerPosUnSS, centerPosVS,   \
-                             useTangentPlane, tangentX, tangentY, mmPerUnit, pixelsPerMm,       \
-                             totalIrradiance, totalWeight)                                      \
-            {                                                                                   \
-                float  r   = kernel[profileID][i][0];                                           \
-                /* The relative sample position is known at compile time. */                    \
-                float  phi = SampleDiskFibonacci(i, n).y;                                       \
-                float2 vec = r * float2(cos(phi), sin(phi));                                    \
-                                                                                                \
-                /* Compute the screen-space position and the associated irradiance. */          \
-                float2 position; float3 irradiance;                                             \
-                /* Compute the squared distance (in mm) in the screen-aligned plane. */         \
-                float dXY2;                                                                     \
-                                                                                                \
-                if (useTangentPlane)                                                            \
-                {                                                                               \
-                    /* 'vec' is given relative to the tangent frame. */                         \
-                    float3 relPosVS   = vec.x * tangentX + vec.y * tangentY;                    \
-                    float3 positionVS = centerPosVS + relPosVS;                                 \
-                    float4 positionCS = mul(projMatrix, float4(positionVS, 1));                 \
-                    float2 positionSS = ComputeScreenSpacePosition(positionCS);                 \
-                                                                                                \
-                    position   = positionSS * _ScreenSize.xy;                                   \
-                    irradiance = LOAD_TEXTURE2D(_IrradianceSource, position).rgb;               \
-                    dXY2       = dot(relPosVS.xy, relPosVS.xy);                                 \
-                }                                                                               \
-                else                                                                            \
-                {                                                                               \
-                    /* 'vec' is given directly in screen-space. */                              \
-                    position   = centerPosUnSS + vec * pixelsPerMm;                             \
-                    irradiance = LOAD_TEXTURE2D(_IrradianceSource, position).rgb;               \
-                    dXY2       = r * r;                                                         \
-                }                                                                               \
-                                                                                                \
-                /* TODO: see if making this a [branch] improves performance. */                 \
-                [flatten]                                                                       \
-                if (any(irradiance))                                                            \
-                {                                                                               \
-                    /* Apply bilateral weighting. */                                            \
-                    float  z = LOAD_TEXTURE2D(_MainDepthTexture, position).r;                   \
-                    float  d = LinearEyeDepth(z, _ZBufferParams);                               \
-                    float  t = d - centerPosVS.z;                                               \
-                    float  p = kernel[profileID][i][1];                                         \
-                    float3 w = ComputeBilateralWeight(dXY2, t, mmPerUnit, shapeParam, p);       \
-                                                                                                \
-                    totalIrradiance += w * irradiance;                                          \
-                    totalWeight     += w;                                                       \
-                }                                                                               \
-                else                                                                            \
-                {                                                                               \
-                    /*************************************************************************/ \
-                    /* The irradiance is 0. This could happen for 3 reasons.                 */ \
-                    /* Most likely, the surface fragment does not have an SSS material.      */ \
-                    /* Alternatively, our sample comes from a region without any geometry.   */ \
-                    /* Finally, the surface fragment could be completely shadowed.           */ \
-                    /* Our blur is energy-preserving, so 'centerWeight' should be set to 0.  */ \
-                    /* We do not terminate the loop since we want to gather the contribution */ \
-                    /* of the remaining samples (e.g. in case of hair covering skin).        */ \
-                    /* Note: See comment in the output of deferred.shader                    */ \
-                    /*************************************************************************/ \
-                }                                                                               \
-            }
-
-            #define SSS_LOOP(n, kernel, profileID, shapeParam, centerPosUnSS, centerPosVS,      \
-                             useTangentPlane, tangentX, tangentY, mmPerUnit, pixelsPerMm,       \
-                             totalIrradiance, totalWeight)                                      \
-            {                                                                                   \
-                float  centerRadius = kernel[profileID][0][0];                                  \
-                float  centerRcpPdf = kernel[profileID][0][1];                                  \
-                float3 centerWeight = KernelValCircle(centerRadius, shapeParam) * centerRcpPdf; \
-                                                                                                \
-                totalIrradiance = centerWeight * centerIrradiance;                              \
-                totalWeight     = centerWeight;                                                 \
-                                                                                                \
-                /* Integrate over the screen-aligned or tangent plane in the view space. */     \
-                [unroll]                                                                        \
-                for (uint i = 1; i < n; i++)                                                    \
-                {                                                                               \
-                    SSS_ITER(i, n, kernel, profileID, shapeParam, centerPosUnSS, centerPosVS,   \
-                             useTangentPlane, tangentX, tangentY, mmPerUnit, pixelsPerMm,       \
-                             totalIrradiance, totalWeight)                                      \
-                }                                                                               \
-            }
-
             struct Attributes
             {
                 uint vertexID : SV_VertexID;
 
                 int    profileID   = bsdfData.subsurfaceProfile;
                 float  distScale   = bsdfData.subsurfaceRadius;
-            #ifdef SSS_MODEL_DISNEY
-                float3 shapeParam  = _ShapeParams[profileID].rgb;
-                float  maxDistance = _ShapeParams[profileID].a;
-            #else
-            #endif
 
                 // Take the first (central) sample.
                 // TODO: copy its neighborhood into LDS.
                 float3 centerPosVS = ComputeViewSpacePosition(centerPosSS, centerDepth, _InvProjMatrix);
                 float3 cornerPosVS = ComputeViewSpacePosition(cornerPosSS, centerDepth, _InvProjMatrix);
 
-            #ifdef SSS_MODEL_DISNEY
-                float mmPerUnit  = MILLIMETERS_PER_METER * (_WorldScales[profileID] / distScale);
-                float unitsPerMm = rcp(mmPerUnit);
-
-                // Compute the view-space dimensions of the pixel as a quad projected onto geometry.
-                float2 unitsPerPixel = 2 * abs(cornerPosVS.xy - centerPosVS.xy);
-                float2 pixelsPerMm   = rcp(unitsPerPixel) * unitsPerMm;
-
-                // We perform point sampling. Therefore, we can avoid the cost
-                // of filtering if we stay within the bounds of the current pixel.
-                // We use the value of 1 instead of 0.5 as an optimization.
-                // N.b.: our LoD selection algorithm is the same regardless of
-                // whether we integrate over the tangent plane or not, since we
-                // don't want the orientation of the tangent plane to create
-                // divergence of execution across the warp.
-                float maxDistInPixels = maxDistance * max(pixelsPerMm.x, pixelsPerMm.y);
-
-                [branch]
-                if (distScale == 0 || maxDistInPixels < 1)
-                {
-                    #if SSS_DEBUG_LOD
-                        return float4(0, 0, 1, 1);
-                    #else
-                        return float4(bsdfData.diffuseColor * centerIrradiance, 1);
-                    #endif
-                }
-
-                const bool useTangentPlane = SSS_USE_TANGENT_PLANE != 0;
-
-                float4x4 viewMatrix, projMatrix;
-                GetLeftHandedViewSpaceMatrices(viewMatrix, projMatrix);
-
-                // Compute the tangent frame in view space.
-                float3 normalVS = mul((float3x3)viewMatrix, bsdfData.normalWS);
-                float3 tangentX = GetLocalFrame(normalVS)[0] * unitsPerMm;
-                float3 tangentY = GetLocalFrame(normalVS)[1] * unitsPerMm;
-
-            #if SSS_DEBUG_NORMAL_VS
-                // We expect the view-space normal to be front-facing.
-                if (normalVS.z >= 0) return float4(1, 0, 0, 1);
-            #endif
-
-                // Accumulate filtered irradiance and bilateral weights (for renormalization).
-                float3 totalIrradiance, totalWeight;
-
-                // Use fewer samples for SS regions smaller than 5x5 pixels (rotated by 45 degrees).
-                [branch]
-                if (maxDistInPixels < SSS_LOD_THRESHOLD)
-                {
-                    #if SSS_DEBUG_LOD
-                        return float4(0.5, 0.5, 0, 1);
-                    #else
-                        SSS_LOOP(SSS_N_SAMPLES_FAR_FIELD, _FilterKernelsFarField,
-                                 profileID, shapeParam, centerPosition, centerPosVS,
-                                 useTangentPlane, tangentX, tangentY, mmPerUnit, pixelsPerMm,
-                                 totalIrradiance, totalWeight)
-                    #endif
-                }
-                else
-                {
-                    #if SSS_DEBUG_LOD
-                        return float4(1, 0, 0, 1);
-                    #else
-                        SSS_LOOP(SSS_N_SAMPLES_NEAR_FIELD, _FilterKernelsNearField,
-                                 profileID, shapeParam, centerPosition, centerPosVS,
-                                 useTangentPlane, tangentX, tangentY, mmPerUnit, pixelsPerMm,
-                                 totalIrradiance, totalWeight)
-                    #endif
-                }
-            #else
-                // Rescaling the filter is equivalent to inversely scaling the world.
-                float  metersPerUnit = _WorldScales[profileID] / distScale * SSS_BASIC_DISTANCE_SCALE;
+                float  metersPerUnit = _WorldScales[profileID].x / distScale * SSS_BASIC_DISTANCE_SCALE;
                 float  centimPerUnit = CENTIMETERS_PER_METER * metersPerUnit;
                 // Compute the view-space dimensions of the pixel as a quad projected onto geometry.
                 float2 unitsPerPixel = 2 * abs(cornerPosVS.xy - centerPosVS.xy);
                         // of the remaining samples (e.g. in case of hair covering skin).
                     }
                 }
-            #endif
 
                 return float4(bsdfData.diffuseColor * totalIrradiance / totalWeight, 1);
             }

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/SSSProfile/SkinSSSProfile.asset

   worldScale: 1
   settingsIndex: 0
   m_ShapeParam: {x: 1.3192612, y: 3.1152647, z: 4.9751244}
-  m_MaxRadius: 8.458925
+  m_MaxRadius: 10.03481
-  - {x: 0, y: 1.516}
-  - {x: 0.027902514, y: 1.5535468}
-  - {x: 0.056502663, y: 1.5927485}
-  - {x: 0.0858313, y: 1.6337082}
-  - {x: 0.1159215, y: 1.6765369}
-  - {x: 0.14680836, y: 1.7213551}
-  - {x: 0.17852913, y: 1.7682924}
-  - {x: 0.21112362, y: 1.81749}
-  - {x: 0.24463426, y: 1.8691009}
-  - {x: 0.27910653, y: 1.9232914}
-  - {x: 0.31458887, y: 1.9802433}
-  - {x: 0.35113326, y: 2.0401537}
-  - {x: 0.3887955, y: 2.1032388}
-  - {x: 0.42763543, y: 2.1697347}
-  - {x: 0.46771717, y: 2.2399004}
-  - {x: 0.5091102, y: 2.3140202}
-  - {x: 0.55188924, y: 2.3924074}
-  - {x: 0.59613484, y: 2.4754071}
-  - {x: 0.6419343, y: 2.563401}
-  - {x: 0.68938226, y: 2.6568115}
-  - {x: 0.7385812, y: 2.756108}
-  - {x: 0.78964317, y: 2.8618138}
-  - {x: 0.8426895, y: 2.9745123}
-  - {x: 0.89785355, y: 3.0948577}
-  - {x: 0.95528066, y: 3.2235847}
-  - {x: 1.0151305, y: 3.3615222}
-  - {x: 1.0775794, y: 3.5096087}
-  - {x: 1.1428206, y: 3.66891}
-  - {x: 1.2110695, y: 3.8406446}
-  - {x: 1.282564, y: 4.026209}
-  - {x: 1.3575704, y: 4.227214}
-  - {x: 1.4363859, y: 4.4455285}
-  - {x: 1.5193442, y: 4.6833334}
-  - {x: 1.6068225, y: 4.943191}
-  - {x: 1.6992486, y: 5.228136}
-  - {x: 1.7971107, y: 5.541792}
-  - {x: 1.9009686, y: 5.88852}
-  - {x: 2.0114706, y: 6.273631}
-  - {x: 2.1293726, y: 6.7036633}
-  - {x: 2.2555614, y: 7.18675}
-  - {x: 2.3910918, y: 7.7331758}
-  - {x: 2.537231, y: 8.35613}
-  - {x: 2.6955185, y: 9.072821}
-  - {x: 2.8678567, y: 9.906171}
-  - {x: 3.056636, y: 10.887414}
-  - {x: 3.2649205, y: 12.060253}
-  - {x: 3.496729, y: 13.487793}
-  - {x: 3.7574923, y: 15.264698}
-  - {x: 4.054809, y: 17.539753}
-  - {x: 4.3997865, y: 20.560957}
-  - {x: 4.8096266, y: 24.774817}
-  - {x: 5.3131247, y: 31.074501}
-  - {x: 5.9642344, y: 41.544285}
-  - {x: 6.884045, y: 62.43729}
-  - {x: 8.458925, y: 125.02069}
+  - {x: 0.013865918, y: 1.5345725}
+  - {x: 0.04211352, y: 1.5729346}
+  - {x: 0.07107388, y: 1.6130018}
+  - {x: 0.100779116, y: 1.6548817}
+  - {x: 0.13126306, y: 1.6986896}
+  - {x: 0.16256203, y: 1.7445502}
+  - {x: 0.1947145, y: 1.7925992}
+  - {x: 0.22776169, y: 1.8429838}
+  - {x: 0.26174724, y: 1.8958628}
+  - {x: 0.29671827, y: 1.9514104}
+  - {x: 0.33272493, y: 2.0098157}
+  - {x: 0.369821, y: 2.0712852}
+  - {x: 0.40806437, y: 2.1360447}
+  - {x: 0.44751683, y: 2.2043417}
+  - {x: 0.48824534, y: 2.276447}
+  - {x: 0.5303216, y: 2.3526597}
+  - {x: 0.5738235, y: 2.433308}
+  - {x: 0.61883456, y: 2.5187542}
+  - {x: 0.665446, y: 2.609401}
+  - {x: 0.713756, y: 2.7056925}
+  - {x: 0.763872, y: 2.808125}
+  - {x: 0.8159103, y: 2.91725}
+  - {x: 0.8699981, y: 3.0336854}
+  - {x: 0.9262747, y: 3.1581244}
+  - {x: 0.98489225, y: 3.2913465}
+  - {x: 1.0460185, y: 3.434234}
+  - {x: 1.1098381, y: 3.5877857}
+  - {x: 1.1765549, y: 3.7531407}
+  - {x: 1.2463952, y: 3.9316032}
+  - {x: 1.319611, y: 4.124672}
+  - {x: 1.3964823, y: 4.3340797}
+  - {x: 1.4773248, y: 4.561845}
+  - {x: 1.5624928, y: 4.810328}
+  - {x: 1.6523882, y: 5.082317}
+  - {x: 1.747467, y: 5.381122}
+  - {x: 1.8482518, y: 5.710715}
+  - {x: 1.9553448, y: 6.0759025}
+  - {x: 2.069445, y: 6.482568}
+  - {x: 2.1913698, y: 6.9379897}
+  - {x: 2.3220856, y: 7.4513016}
+  - {x: 2.4627466, y: 8.0341215}
+  - {x: 2.614747, y: 8.701484}
+  - {x: 2.7797952, y: 9.473195}
+  - {x: 2.9600194, y: 10.375936}
+  - {x: 3.1581159, y: 11.446505}
+  - {x: 3.3775842, y: 12.737201}
+  - {x: 3.6230793, y: 14.324919}
+  - {x: 3.9009922, y: 16.327562}
+  - {x: 4.220452, y: 18.935623}
+  - {x: 4.5951686, y: 22.478209}
+  - {x: 5.047148, y: 27.57712}
+  - {x: 5.615129, y: 35.564823}
+  - {x: 6.3776174, y: 49.90625}
+  - {x: 7.5374603, y: 83.30668}
+  - {x: 10.03481, y: 250.11497}
-  - {x: 0, y: 1.516}
-  - {x: 0.07457052, y: 1.6178904}
-  - {x: 0.15428384, y: 1.7323332}
-  - {x: 0.23978925, y: 1.861574}
-  - {x: 0.33185518, y: 2.0083904}
-  - {x: 0.43139812, y: 2.1762547}
-  - {x: 0.53952074, y: 2.3695562}
-  - {x: 0.6575622, y: 2.5939138}
-  - {x: 0.7871677, y: 2.8566267}
-  - {x: 0.93038195, y: 3.1673388}
-  - {x: 1.0897847, y: 3.5390525}
-  - {x: 1.2686841, y: 3.9897263}
-  - {x: 1.4714115, y: 4.544919}
-  - {x: 1.7037815, y: 5.2423906}
-  - {x: 1.9738544, y: 6.140622}
-  - {x: 2.2932806, y: 7.335897}
-  - {x: 2.679871, y: 8.999949}
-  - {x: 3.1630776, y: 11.474433}
-  - {x: 3.797516, y: 15.554795}
-  - {x: 4.7049003, y: 23.627026}
-  - {x: 6.2721014, y: 47.62654}
+  - {x: 0.03667902, y: 1.5654991}
+  - {x: 0.11374626, y: 1.6734134}
+  - {x: 0.19626758, y: 1.7949444}
+  - {x: 0.28494877, y: 1.9325867}
+  - {x: 0.38062802, y: 2.0894418}
+  - {x: 0.48430943, y: 2.2694077}
+  - {x: 0.59720695, y: 2.4774427}
+  - {x: 0.72080237, y: 2.7199378}
+  - {x: 0.8569269, y: 3.005264}
+  - {x: 1.007873, y: 3.3445888}
+  - {x: 1.1765549, y: 3.7531407}
+  - {x: 1.3667475, y: 4.252257}
+  - {x: 1.5834517, y: 4.872841}
+  - {x: 1.8334827, y: 5.6615734}
+  - {x: 2.126473, y: 6.692844}
+  - {x: 2.4767098, y: 8.093767}
+  - {x: 2.9068332, y: 10.102725}
+  - {x: 3.4562516, y: 13.228675}
+  - {x: 4.2041187, y: 18.793621}
+  - {x: 5.3538504, y: 31.646347}
+  - {x: 7.84603, y: 95.44374}
   scatterDistance1: {r: 0.3, g: 0.2, b: 0.2, a: 0}
   scatterDistance2: {r: 0.6, g: 0.2, b: 0.2, a: 0}
   lerpWeight: 0.5

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/SubsurfaceScatteringProfile.cs

     {
         public int                           numProfiles;               // Excluding the neutral profile
         public SubsurfaceScatteringProfile[] profiles;
-        // Below are the cached values.
-        [NonSerialized] public uint          texturingModeFlags;        // 1 bit/profile; 0 = PreAndPostScatter, 1 = PostScatter
-        [NonSerialized] public uint          transmissionFlags;         // 2 bit/profile; 0 = inf. thick, 1 = thin, 2 = regular
-        [NonSerialized] public Vector4[]     thicknessRemaps;           // Remap: 0 = start, 1 = end - start
-        [NonSerialized] public float[]       worldScales;               // Size of the world unit in meters
-        [NonSerialized] public Vector4[]     shapeParams;               // RGB = S = 1 / D, A = filter radius
-        [NonSerialized] public Vector4[]     transmissionTints;         // RGB = color, A = unused
-        [NonSerialized] public float[]       filterKernelsNearField;    // 0 = radius, 1 = reciprocal of the PDF
-        [NonSerialized] public float[]       filterKernelsFarField;     // 0 = radius, 1 = reciprocal of the PDF
+        // Below are the cached values. TODO: uncomment when SSS profile asset serialization is fixed.
+        /*[NonSerialized]*/ public int           texturingModeFlags;        // 1 bit/profile; 0 = PreAndPostScatter, 1 = PostScatter
+        /*[NonSerialized]*/ public int           transmissionFlags;         // 2 bit/profile; 0 = inf. thick, 1 = thin, 2 = regular
+        /*[NonSerialized]*/ public Vector4[]     thicknessRemaps;           // Remap: 0 = start, 1 = end - start
+        /*[NonSerialized]*/ public Vector4[]     worldScales;               // Size of the world unit in meters (only the X component is used)
+        /*[NonSerialized]*/ public Vector4[]     shapeParams;               // RGB = S = 1 / D, A = filter radius
+        /*[NonSerialized]*/ public Vector4[]     transmissionTints;         // RGB = color, A = unused
+        /*[NonSerialized]*/ public Vector4[]     filterKernels;             // XY = near field, ZW = far field; 0 = radius, 1 = reciprocal of the PDF
-        [NonSerialized] public Vector4[]     halfRcpWeightedVariances;
-        [NonSerialized] public Vector4[]     filterKernelsBasic;
+        /*[NonSerialized]*/ public Vector4[]     halfRcpWeightedVariances;
+        /*[NonSerialized]*/ public Vector4[]     filterKernelsBasic;
         // <<< Old SSS Model
 
         // --- Public Methods ---
             worldScales            = null;
             shapeParams            = null;
             transmissionTints      = null;
-            filterKernelsNearField = null;
-            filterKernelsFarField  = null;
+            filterKernels          = null;
             // Old SSS Model >>>
             useDisneySSS             = true;
             halfRcpWeightedVariances = null;
 
             if (worldScales == null || worldScales.Length != SssConstants.SSS_N_PROFILES)
             {
-                worldScales = new float[SssConstants.SSS_N_PROFILES];
+                worldScales = new Vector4[SssConstants.SSS_N_PROFILES];
             }
 
             if (shapeParams == null || shapeParams.Length != SssConstants.SSS_N_PROFILES)
                 transmissionTints = new Vector4[SssConstants.SSS_N_PROFILES];
             }
 
-            const int filterKernelsNearFieldLen = 2 * SssConstants.SSS_N_PROFILES * SssConstants.SSS_N_SAMPLES_NEAR_FIELD;
-            if (filterKernelsNearField == null || filterKernelsNearField.Length != filterKernelsNearFieldLen)
+            const int filterKernelsNearFieldLen = SssConstants.SSS_N_PROFILES * SssConstants.SSS_N_SAMPLES_NEAR_FIELD;
+            if (filterKernels == null || filterKernels.Length != filterKernelsNearFieldLen)
-                filterKernelsNearField = new float[filterKernelsNearFieldLen];
-            }
-
-            const int filterKernelsFarFieldLen = 2 * SssConstants.SSS_N_PROFILES * SssConstants.SSS_N_SAMPLES_FAR_FIELD;
-            if (filterKernelsFarField == null || filterKernelsFarField.Length != filterKernelsFarFieldLen)
-            {
-                filterKernelsFarField = new float[filterKernelsFarFieldLen];
+                filterKernels = new Vector4[filterKernelsNearFieldLen];
             }
 
             // Old SSS Model >>>
                 if (i >= numProfiles || profiles[i] == null)
                 {
                     // Pink transmission
-                    transmissionFlags |= (uint)1 << i * 2;
+                    transmissionFlags |= 1 << i * 2;
-                    worldScales[i] = 1.0f;
+                    worldScales[i] = Vector4.one;
-                        filterKernelsNearField[2 * (n * i + j) + 0] = 0.0f;
-                        filterKernelsNearField[2 * (n * i + j) + 1] = 1.0f;
-                    }
-
-                    for (int j = 0, n = SssConstants.SSS_N_SAMPLES_FAR_FIELD; j < n; j++)
-                    {
-                        filterKernelsFarField[2 * (n * i + j) + 0] = 0.0f;
-                        filterKernelsFarField[2 * (n * i + j) + 1] = 1.0f;
+                        filterKernels[n * i + j].x = 0.0f;
+                        filterKernels[n * i + j].y = 1.0f;
+                        filterKernels[n * i + j].z = 0.0f;
+                        filterKernels[n * i + j].w = 1.0f;
                     }
 
                     // Old SSS Model >>>
 
                 Debug.Assert(numProfiles < 16, "Transmission flags (32-bit integer) cannot support more than 16 profiles.");
 
-                texturingModeFlags |= (uint)profiles[i].texturingMode    << i;
-                transmissionFlags  |= (uint)profiles[i].transmissionMode << i * 2;
+                texturingModeFlags |= (int)profiles[i].texturingMode    << i;
+                transmissionFlags  |= (int)profiles[i].transmissionMode << i * 2;
-                thicknessRemaps[i]         = new Vector4(profiles[i].thicknessRemap.x, profiles[i].thicknessRemap.y - profiles[i].thicknessRemap.x, 0.0f, 0.0f);
-                worldScales[i]             = profiles[i].worldScale;
-                shapeParams[i]             = profiles[i].shapeParameter;
-                shapeParams[i].w           = profiles[i].maxRadius;
-                transmissionTints[i]       = profiles[i].transmissionTint;
+                thicknessRemaps[i]   = new Vector4(profiles[i].thicknessRemap.x, profiles[i].thicknessRemap.y - profiles[i].thicknessRemap.x, 0.0f, 0.0f);
+                worldScales[i]       = new Vector4(profiles[i].worldScale, 0, 0, 0);
+                shapeParams[i]       = profiles[i].shapeParameter;
+                shapeParams[i].w     = profiles[i].maxRadius;
+                transmissionTints[i] = profiles[i].transmissionTint;
-                    filterKernelsNearField[2 * (n * i + j) + 0] = profiles[i].filterKernelNearField[j].x;
-                    filterKernelsNearField[2 * (n * i + j) + 1] = profiles[i].filterKernelNearField[j].y;
-                }
+                    filterKernels[n * i + j].x = profiles[i].filterKernelNearField[j].x;
+                    filterKernels[n * i + j].y = profiles[i].filterKernelNearField[j].y;
-                for (int j = 0, n = SssConstants.SSS_N_SAMPLES_FAR_FIELD; j < n; j++)
-                {
-                    filterKernelsFarField[2 * (n * i + j) + 0] = profiles[i].filterKernelFarField[j].x;
-                    filterKernelsFarField[2 * (n * i + j) + 1] = profiles[i].filterKernelFarField[j].y;
+                    if (j < SssConstants.SSS_N_SAMPLES_FAR_FIELD)
+                    {
+                        filterKernels[n * i + j].z = profiles[i].filterKernelFarField[j].x;
+                        filterKernels[n * i + j].w = profiles[i].filterKernelFarField[j].y;
+                    }
                 }
 
                 // Old SSS Model >>>
             {
                 int i = SssConstants.SSS_NEUTRAL_PROFILE_ID;
 
-                worldScales[i] = 1.0f;
+                worldScales[i] = Vector4.one;
-                    filterKernelsNearField[2 * (n * i + j) + 0] = 0.0f;
-                    filterKernelsNearField[2 * (n * i + j) + 1] = 1.0f;
-                }
-
-                for (int j = 0, n = SssConstants.SSS_N_SAMPLES_FAR_FIELD; j < n; j++)
-                {
-                    filterKernelsFarField[2 * (n * i + j) + 0] = 0.0f;
-                    filterKernelsFarField[2 * (n * i + j) + 1] = 1.0f;
+                    filterKernels[n * i + j].x = 0.0f;
+                    filterKernels[n * i + j].y = 1.0f;
+                    filterKernels[n * i + j].z = 0.0f;
+                    filterKernels[n * i + j].w = 1.0f;
                 }
 
                 // Old SSS Model >>>
 
         public void OnAfterDeserialize()
         {
-            UpdateCache();
+            // TODO: uncomment when SSS profile asset serialization is fixed.
+            // UpdateCache();
         }
     }
 
             bool transmissionEnabled = m_TransmissionMode.intValue != (int)SubsurfaceScatteringProfile.TransmissionMode.None;
 
             // Draw the profile.
-            m_ProfileMaterial.SetFloat( "_MaxRadius",  r);
-            m_ProfileMaterial.SetVector("_ShapeParam", S);
+            m_ProfileMaterial.SetFloat(HDShaderIDs._MaxRadius,  r);
+            m_ProfileMaterial.SetVector(HDShaderIDs._ShapeParam, S);
             // Old SSS Model >>>
             Utilities.SelectKeyword(m_ProfileMaterial, "SSS_MODEL_DISNEY", "SSS_MODEL_BASIC", useDisneySSS);
             // Apply the three-sigma rule, and rescale.
             Vector4 stdDev1 = new Vector4(s * m_ScatterDistance1.colorValue.r, s * m_ScatterDistance1.colorValue.g, s * m_ScatterDistance1.colorValue.b);
             Vector4 stdDev2 = new Vector4(s * m_ScatterDistance2.colorValue.r, s * m_ScatterDistance2.colorValue.g, s * m_ScatterDistance2.colorValue.b);
-            m_ProfileMaterial.SetVector("_StdDev1",   stdDev1);
-            m_ProfileMaterial.SetVector("_StdDev2",   stdDev2);
-            m_ProfileMaterial.SetFloat("_LerpWeight", m_LerpWeight.floatValue);
-            m_ProfileMaterial.SetFloat("_MaxRadius",  rMax);
+            m_ProfileMaterial.SetVector(HDShaderIDs._StdDev1,   stdDev1);
+            m_ProfileMaterial.SetVector(HDShaderIDs._StdDev2,   stdDev2);
+            m_ProfileMaterial.SetFloat(HDShaderIDs._LerpWeight, m_LerpWeight.floatValue);
+            m_ProfileMaterial.SetFloat(HDShaderIDs._MaxRadius,  rMax);
             // <<< Old SSS Model
             EditorGUI.DrawPreviewTexture(GUILayoutUtility.GetRect(256, 256), m_ProfileImage, m_ProfileMaterial, ScaleMode.ScaleToFit, 1.0f);
 
             EditorGUILayout.Space();
 
             // Draw the transmittance graph.
-            m_TransmittanceMaterial.SetVector("_ShapeParam",       S);
-            m_TransmittanceMaterial.SetVector("_TransmissionTint", transmissionEnabled ? T : Vector4.zero);
-            m_TransmittanceMaterial.SetVector("_ThicknessRemap",   R);
+            m_TransmittanceMaterial.SetVector(HDShaderIDs._ShapeParam,       S);
+            m_TransmittanceMaterial.SetVector(HDShaderIDs._TransmissionTint, transmissionEnabled ? T : Vector4.zero);
+            m_TransmittanceMaterial.SetVector(HDShaderIDs._ThicknessRemap,   R);
             EditorGUI.DrawPreviewTexture(GUILayoutUtility.GetRect(16, 16), m_TransmittanceImage, m_TransmittanceMaterial, ScaleMode.ScaleToFit, 16.0f);
 
             serializedObject.ApplyModifiedProperties();

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Unlit/Unlit.shader

     //-------------------------------------------------------------------------------------
 
     #include "../../../ShaderLibrary/common.hlsl"
-    #include "../../ShaderConfig.cs.hlsl"
     #include "../../ShaderVariables.hlsl"
     #include "../../ShaderPass/FragInputs.hlsl"
     #include "../../ShaderPass/ShaderPass.cs.hlsl"

Assets/ScriptableRenderPipeline/HDRenderPipeline/RenderPipelineResources/CameraMotionVectors.shader

 
         #include "../../ShaderLibrary/Common.hlsl"
         #include "../ShaderVariables.hlsl"
-        #include "../ShaderConfig.cs.hlsl"
         #include "../ShaderPass/FragInputs.hlsl"
         #include "../ShaderPass/VaryingMesh.hlsl"
         #include "../ShaderPass/VertMesh.hlsl"

Assets/ScriptableRenderPipeline/HDRenderPipeline/RenderPipelineResources/HDRenderPipelineResources.asset

   deferredShader: {fileID: 4800000, guid: 00dd221e34a6ab349a1196b0f2fab693, type: 3}
   screenSpaceAmbientOcclusionShader: {fileID: 4800000, guid: cf0db7f5267ad944dbf4326b7102c9ca,
     type: 3}
+  subsurfaceScatteringCS: {fileID: 7200000, guid: b06a7993621def248addd55d0fe931b1,
+    type: 3}
   clearDispatchIndirectShader: {fileID: 7200000, guid: fc1f553acb80a6446a32d33e403d0656,
     type: 3}
   buildDispatchIndirectShader: {fileID: 7200000, guid: 4eb1b418be7044c40bb5200496c50f14,
     type: 3}
   buildMaterialFlagsShader: {fileID: 7200000, guid: fb3eda953cd6e634e877fb777be2cd08,
     type: 3}
-  shadeOpaqueShader: {fileID: 7200000, guid: 0b64f79746d2daf4198eaf6eab9af259, type: 3}
+  deferredComputeShader: {fileID: 7200000, guid: 0b64f79746d2daf4198eaf6eab9af259,
+    type: 3}
   cameraMotionVectors: {fileID: 4800000, guid: 035941b63024d1943af48811c1db20d9, type: 3}
   blitCubemap: {fileID: 4800000, guid: d05913e251bed7a4992c921c62e1b647, type: 3}
   buildProbabilityTables: {fileID: 7200000, guid: b9f26cf340afe9145a699753531b2a4c,

Assets/ScriptableRenderPipeline/HDRenderPipeline/RenderPipelineResources/RenderPipelineResources.cs

 
             instance.deferredShader = UnityEditor.AssetDatabase.LoadAssetAtPath<Shader>("Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/Deferred.Shader");
             instance.screenSpaceAmbientOcclusionShader = UnityEditor.AssetDatabase.LoadAssetAtPath<Shader>("Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/AmbientOcclusion/ScreenSpaceAmbientOcclusion.Shader");
+            instance.subsurfaceScatteringCS = UnityEditor.AssetDatabase.LoadAssetAtPath<ComputeShader>("Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Resources/SubsurfaceScattering.compute");
 
             instance.clearDispatchIndirectShader = UnityEditor.AssetDatabase.LoadAssetAtPath<ComputeShader>("Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/cleardispatchindirect.compute");
             instance.buildDispatchIndirectShader = UnityEditor.AssetDatabase.LoadAssetAtPath<ComputeShader>("Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/builddispatchindirect.compute");
             instance.buildPerVoxelLightListShader = UnityEditor.AssetDatabase.LoadAssetAtPath<ComputeShader>("Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/lightlistbuild-clustered.compute");
             instance.buildMaterialFlagsShader = UnityEditor.AssetDatabase.LoadAssetAtPath<ComputeShader>("Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/materialflags.compute");
-            instance.shadeOpaqueShader = UnityEditor.AssetDatabase.LoadAssetAtPath<ComputeShader>("Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/shadeopaque.compute");
+            instance.deferredComputeShader = UnityEditor.AssetDatabase.LoadAssetAtPath<ComputeShader>("Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/Deferred.compute");
 
             // SceneSettings
             // These shaders don't need to be reference by RenderPipelineResource as they are not use at runtime (only to draw in editor)
         // Lighting resources
         public Shader deferredShader;
         public Shader screenSpaceAmbientOcclusionShader;
+        public ComputeShader subsurfaceScatteringCS;
 
         // Lighting tile pass resources
         public ComputeShader clearDispatchIndirectShader;
         public ComputeShader buildPerBigTileLightListShader;
         public ComputeShader buildPerVoxelLightListShader;    // clustered
         public ComputeShader buildMaterialFlagsShader;
-        public ComputeShader shadeOpaqueShader;
+        public ComputeShader deferredComputeShader;
 
         // SceneSettings
         // These shaders don't need to be reference by RenderPipelineResource as they are not use at runtime (only to draw in editor)

Assets/ScriptableRenderPipeline/HDRenderPipeline/ShaderPass/ShaderPassForward.hlsl

-#if SHADERPASS != SHADERPASS_FORWARD
+#if SHADERPASS != SHADERPASS_FORWARD
 #error SHADERPASS_is_not_correctly_define
 #endif
 
 
     PreLightData preLightData = GetPreLightData(V, posInput, bsdfData);
 
+    outColor = float4(0.0, 0.0, 0.0, 0.0);
+
+    // We need to skip lighting when doing debug pass because the debug pass is done before lighting so some buffers may not be properly initialized potentially causing crashes on PS4.
+#ifdef DEBUG_DISPLAY
+    if (_DebugLightingMode != DEBUGLIGHTINGMODE_NONE)
+#endif
+    {
     uint featureFlags = 0xFFFFFFFF;
     float3 diffuseLighting;
     float3 specularLighting;
     outColor = float4(diffuseLighting + specularLighting, builtinData.opacity);
+    }
 
 #ifdef _DEPTHOFFSET_ON
     outputDepth = posInput.depthRaw;

Assets/ScriptableRenderPipeline/HDRenderPipeline/ShaderVariables.hlsl

 #ifndef UNITY_SHADER_VARIABLES_INCLUDED
 #define UNITY_SHADER_VARIABLES_INCLUDED
 
+#include "ShaderConfig.cs.hlsl"
+
 // CAUTION:
 // Currently the shaders compiler always include regualr Unity shaderVariables, so I get a conflict here were UNITY_SHADER_VARIABLES_INCLUDED is already define, this need to be fixed.
 // As I haven't change the variables name yet, I simply don't define anything, and I put the transform function at the end of the file outside the guard header.

Assets/ScriptableRenderPipeline/HDRenderPipeline/Sky/HDRISky/HDRISkyRenderer.cs

 
         public override void RenderSky(BuiltinSkyParameters builtinParams, SkySettings skyParameters, bool renderForCubemap)
         {
-            m_SkyHDRIMaterial.SetTexture("_Cubemap", m_HdriSkyParams.skyHDRI);
-            m_SkyHDRIMaterial.SetVector("_SkyParam", new Vector4(m_HdriSkyParams.exposure, m_HdriSkyParams.multiplier, m_HdriSkyParams.rotation, 0.0f));
+            m_SkyHDRIMaterial.SetTexture(HDShaderIDs._Cubemap, m_HdriSkyParams.skyHDRI);
+            m_SkyHDRIMaterial.SetVector(HDShaderIDs._SkyParam, new Vector4(m_HdriSkyParams.exposure, m_HdriSkyParams.multiplier, m_HdriSkyParams.rotation, 0.0f));
 
             builtinParams.commandBuffer.DrawMesh(builtinParams.skyMesh, Matrix4x4.identity, m_SkyHDRIMaterial, 0, renderForCubemap ? 0 : 1);
         }

Assets/ScriptableRenderPipeline/HDRenderPipeline/Sky/SkyManager.cs

 
             // Flip texture.
             // Temporarily disabled until proper API reaches trunk
-            //Graphics.Blit(temp, tempRT, new Vector2(1.0f, -1.0f), new Vector2(0.0f, 0.0f));
-            Graphics.Blit(temp, tempRT);
-
+            Graphics.Blit(temp, tempRT, new Vector2(1.0f, -1.0f), new Vector2(0.0f, 0.0f));
+            
             result.ReadPixels(new Rect(0, 0, resolution * 6, resolution), 0, 0);
             result.Apply();
 

Assets/ScriptableRenderPipeline/LightweightPipeline/LightweightPipeline.cs

 using System;
 using UnityEngine.Rendering;
+using UnityEngine.XR;
 
 namespace UnityEngine.Experimental.Rendering.LightweightPipeline
 {
         private RenderTargetIdentifier m_CameraRTID;
 
         private bool m_RenderToIntermediateTarget = false;
+        private bool m_IntermediateTextureArray = false;
 
         private const int kShadowDepthBufferBits = 16;
         private const int kCameraDepthBufferBits = 32;
         {
             base.Render(context, cameras);
 
+            bool stereoEnabled = XRSettings.isDeviceActive;
+
-                if (!CullResults.GetCullingParameters(camera, out cullingParameters))
+                if (!CullResults.GetCullingParameters(camera, stereoEnabled, out cullingParameters))
                     continue;
 
                 cullingParameters.shadowDistance = Mathf.Min(m_ShadowSettings.maxShadowDistance, camera.farClipPlane);
                     lightData.shadowsRendered = RenderShadows(ref m_CullResults, ref visibleLights[lightData.shadowLightIndex], lightData.shadowLightIndex, ref context);
 
                 // Setup camera matrices and RT
-                context.SetupCameraProperties(camera);
+                context.SetupCameraProperties(camera, stereoEnabled);
 
                 // Setup light and shadow shader constants
                 SetupShaderLightConstants(visibleLights, ref lightData, ref m_CullResults, ref context);
                 if (!lightData.isSingleDirectionalLight)
                     configuration |= RendererConfiguration.PerObjectLightIndices8;
 
-                BeginForwardRendering(camera, ref context);
+                BeginForwardRendering(camera, ref context, stereoEnabled);
 
                 // Render Opaques
                 var litSettings = new DrawRendererSettings(m_CullResults, camera, m_LitPassName);
 
                 context.DrawRenderers(ref litSettings);
 
-                // Release temporary RT
-                var discardRT = CommandBufferPool.Get();
-                discardRT.ReleaseTemporaryRT(m_ShadowMapProperty);
-                discardRT.ReleaseTemporaryRT(m_CameraRTProperty);
-                context.ExecuteCommandBuffer(discardRT);
-                CommandBufferPool.Release(discardRT);
-
                 // TODO: Check skybox shader
                 context.DrawSkybox(camera);
 
                 context.DrawRenderers(ref litSettings);
                 context.DrawRenderers(ref unlitSettings);
 
-                EndForwardRendering(camera, ref context);
+                EndForwardRendering(camera, ref context, stereoEnabled);
+
+                // Release temporary RT
+                var discardRT = CommandBufferPool.Get();
+                discardRT.ReleaseTemporaryRT(m_ShadowMapProperty);
+                discardRT.ReleaseTemporaryRT(m_CameraRTProperty);
+                context.ExecuteCommandBuffer(discardRT);
+                CommandBufferPool.Release(discardRT);
             }
 
             context.Submit();
             return (type == LightType.Directional || type == LightType.Spot);
         }
 
-        private void BeginForwardRendering(Camera camera, ref ScriptableRenderContext context)
+        private void BeginForwardRendering(Camera camera, ref ScriptableRenderContext context, bool stereoEnabled)
+            if (stereoEnabled)
+                context.StartMultiEye(camera);
+
             m_RenderToIntermediateTarget = GetRenderToIntermediateTarget(camera);
 
             var cmd = CommandBufferPool.Get("SetCameraRenderTarget");
                 {
-                    cmd.GetTemporaryRT(m_CameraRTProperty, Screen.width, Screen.height, kCameraDepthBufferBits,
-                        FilterMode.Bilinear, RenderTextureFormat.ARGB32, RenderTextureReadWrite.Default, m_Asset.MSAASampleCount);
-                    cmd.SetRenderTarget(m_CameraRTID);
+                    m_IntermediateTextureArray = false;
+                    if (stereoEnabled)
+                    {
+                        RenderTextureDescriptor xrDesc = XRSettings.eyeTextureDesc;
+                        xrDesc.depthBufferBits = kCameraDepthBufferBits;
+                        xrDesc.colorFormat = RenderTextureFormat.ARGB32;
+                        xrDesc.msaaSamples = m_Asset.MSAASampleCount;
+
+                        m_IntermediateTextureArray = (xrDesc.dimension == TextureDimension.Tex2DArray);
+
+                        cmd.GetTemporaryRT(m_CameraRTProperty, xrDesc, FilterMode.Bilinear);
+                    }
+                    else
+                    {
+                        cmd.GetTemporaryRT(m_CameraRTProperty, Screen.width, Screen.height, kCameraDepthBufferBits,
+                            FilterMode.Bilinear, RenderTextureFormat.ARGB32, RenderTextureReadWrite.Default, m_Asset.MSAASampleCount);
+                    }
+
+                    if (m_IntermediateTextureArray)
+                        cmd.SetRenderTarget(m_CameraRTID, 0, CubemapFace.Unknown, -1);
+                    else
+                        cmd.SetRenderTarget(m_CameraRTID);
                 }
                 else
                 {
             else
             {
-                cmd.SetRenderTarget(BuiltinRenderTextureType.None);
+                cmd.SetRenderTarget(BuiltinRenderTextureType.CurrentActive);
-                cmd.ClearRenderTarget(camera.clearFlags == CameraClearFlags.Color, camera.clearFlags == CameraClearFlags.Color || camera.clearFlags == CameraClearFlags.Depth, camera.backgroundColor);
+            {
+                bool clearDepth = (camera.clearFlags != CameraClearFlags.Nothing);
+                bool clearColor = (camera.clearFlags == CameraClearFlags.Color);
+                cmd.ClearRenderTarget(clearDepth, clearColor, camera.backgroundColor);
+
+            }
-        private void EndForwardRendering(Camera camera, ref ScriptableRenderContext context)
+        private void EndForwardRendering(Camera camera, ref ScriptableRenderContext context, bool stereoEnabled)
-            if (!m_RenderToIntermediateTarget)
-                return;
+            if (m_RenderToIntermediateTarget)
+            {
+                var cmd = CommandBufferPool.Get("Blit");
+                if (m_IntermediateTextureArray)
+                {
+                    cmd.SetRenderTarget(BuiltinRenderTextureType.CameraTarget, 0, CubemapFace.Unknown, -1);
+                    cmd.Blit(m_CameraRTID, BuiltinRenderTextureType.CurrentActive);
+                }
+                else
+                    cmd.Blit(BuiltinRenderTextureType.CurrentActive, BuiltinRenderTextureType.CameraTarget);
+
+                if (camera.cameraType == CameraType.SceneView)
+                    cmd.SetRenderTarget(BuiltinRenderTextureType.CameraTarget);
+                context.ExecuteCommandBuffer(cmd);
+                CommandBufferPool.Release(cmd);
+            }
-            var cmd = CommandBufferPool.Get("Blit");
-            cmd.Blit(BuiltinRenderTextureType.CurrentActive, BuiltinRenderTextureType.CameraTarget);
-            if (camera.cameraType == CameraType.SceneView)
-                cmd.SetRenderTarget(BuiltinRenderTextureType.CameraTarget);
-            context.ExecuteCommandBuffer(cmd);
-            CommandBufferPool.Release(cmd);
+            if (stereoEnabled)
+            {
+                context.StopMultiEye(camera);
+                context.StereoEndRender(camera);
+            }
         }
 
         private bool GetRenderToIntermediateTarget(Camera camera)

Assets/ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightPipeline.shader

             #pragma shader_feature _EMISSION
             #pragma shader_feature _ _REFLECTION_CUBEMAP _REFLECTION_PROBE
 
+            #pragma multi_compile _ UNITY_SINGLE_PASS_STEREO STEREO_INSTANCING_ON STEREO_MULTIVIEW_ON
             #pragma multi_compile _ _SINGLE_DIRECTIONAL_LIGHT
             #pragma multi_compile _ LIGHTMAP_ON
             #pragma multi_compile _ _LIGHT_PROBES_ON
             v2f vert(LightweightVertexInput v)
             {
                 v2f o = (v2f)0;
+
+                UNITY_SETUP_INSTANCE_ID(v);
+                UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
 
                 o.uv01.xy = TRANSFORM_TEX(v.texcoord, _MainTex);
                 o.uv01.zw = v.lightmapUV * unity_LightmapST.xy + unity_LightmapST.zw;

Assets/ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightPipelineCore.cginc

     float4 tangent : TANGENT;
     float3 texcoord : TEXCOORD0;
     float2 lightmapUV : TEXCOORD1;
+    UNITY_VERTEX_INPUT_INSTANCE_ID
 };
 
 struct v2f
     half4 viewDir : TEXCOORD5; // xyz: viewDir
     UNITY_FOG_COORDS_PACKED(6, half4) // x: fogCoord, yzw: vertexColor
     float4 hpos : SV_POSITION;
+    UNITY_VERTEX_OUTPUT_STEREO
 };
 
 // Per object light list data

Assets/ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightUnlit.shader

             CGPROGRAM
             #pragma vertex vert
             #pragma fragment frag
+            #pragma multi_compile _ UNITY_SINGLE_PASS_STEREO STEREO_INSTANCING_ON STEREO_MULTIVIEW_ON
             #pragma multi_compile_fog
             #pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON
 
             {
                 float4 vertex : POSITION;
                 float2 uv : TEXCOORD0;
+                UNITY_VERTEX_INPUT_INSTANCE_ID
             };
 
             struct v2f
                 float4 vertex : SV_POSITION;
+                UNITY_VERTEX_OUTPUT_STEREO
             };
 
             sampler2D _MainTex;
             v2f vert(appdata v)
             {
                 v2f o;
+
+                UNITY_SETUP_INSTANCE_ID(v);
+                UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
+
                 o.vertex = UnityObjectToClipPos(v.vertex);
                 o.uv = TRANSFORM_TEX(v.uv, _MainTex);
                 UNITY_TRANSFER_FOG(o,o.vertex);

Assets/ScriptableRenderPipeline/ShaderLibrary/API/D3D11.hlsl

 #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 SAMPLER2D(samplerName) SamplerState samplerName
 #define SAMPLERCUBE(samplerName) SamplerState samplerName

Assets/ScriptableRenderPipeline/ShaderLibrary/API/Metal.hlsl

 #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 SAMPLER2D(samplerName) SamplerState samplerName
 #define SAMPLERCUBE(samplerName) SamplerState samplerName

Assets/ScriptableRenderPipeline/ShaderLibrary/API/PSSL.hlsl

 #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 SAMPLER2D(samplerName) SamplerState samplerName
 #define SAMPLERCUBE(samplerName) SamplerState samplerName

Assets/ScriptableRenderPipeline/ShaderLibrary/Common.hlsl

 #endif
 #include "API/Validate.hlsl"
 
+#include "Noise.hlsl"
+
 // Some shader compiler don't support to do multiple ## for concatenation inside the same macro, it require an indirection.
 // This is the purpose of this macro
 #define MERGE_NAME(X, Y) X##Y
 #define INV_FOUR_PI 0.07957747155
 #define HALF_PI     1.57079632679
 #define INV_HALF_PI 0.636619772367
+#define INFINITY    asfloat(0x7F800000)
 
 #define FLT_EPSILON 1.192092896e-07 // Smallest positive number, such that 1.0 + FLT_EPSILON != 1.0
 #define FLT_MIN     1.175494351e-38 // Minimum representable positive floating-point number
 }
 
 // LOD dithering transition helper
-// ditherFactor should be a quantized value between 0..15/16, i.e the one provide by Unity
-// LOD1 must use this functoin with ditherFactor 0..1
+// LOD1 must use this function with ditherFactor 0..1
-    // Generate a fixed pattern
-    float p = cos(dot(unPositionSS, float2(443.8975, 397.2973)));
-    p = frac(p * 491.1871);
+    // Generate a spatially varying pattern.
+    // Unfortunately, varying the pattern with time confuses the TAA, increasing the amount of noise.
+    float p = GenerateHashedRandomFloat(unPositionSS);
-    p = (ditherFactor >= 0.5) ? (15.0 / 16.0) - p : p;
+    p = (ditherFactor >= 0.5) ? p : 1 - p;
     clip(ditherFactor - p);
 }
 

Assets/ScriptableRenderPipeline/ShaderLibrary/Shadow/Shadow.hlsl

 // directional light shadows
 float GetDirectionalShadowAttenuationDefault( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float3 L )
 {
-	return EvalShadow_CascadedDepth( shadowContext, positionWS, normalWS, shadowDataIndex, L );
+	return EvalShadow_CascadedDepth_Blend( shadowContext, positionWS, normalWS, shadowDataIndex, L );
 }
 float GetDirectionalShadowAttenuationDefault( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float3 L, float2 unPositionSS )
 {

Assets/ScriptableRenderPipeline/ShaderLibrary/Shadow/ShadowAlgorithms.hlsl

 }
 
 // function called by spot, point and directional eval routines to calculate shadow coordinates
-float3 EvalShadow_GetTexcoords( ShadowData sd, float3 positionWS )
+float3 EvalShadow_GetTexcoords( ShadowData sd, float3 positionWS, out float3 posNDC, bool clampToRect )
-	float4 posCS = mul( float4( positionWS, 1.0 ), sd.worldToShadow );
+	float4 posCS = mul(float4(positionWS, 1.0), sd.worldToShadow);
-	float3 posNDC = posCS.xyz / posCS.w;
+	posNDC = posCS.xyz / posCS.w;
+	posTC.xy = clampToRect ? clamp( posTC.xy, sd.texelSizeRcp.zw*0.5, 1.0.xx - sd.texelSizeRcp.zw*0.5 ) : posTC.xy;
+}
+
+float3 EvalShadow_GetTexcoords( ShadowData sd, float3 positionWS )
+{
+	float3 ndc;
+	return EvalShadow_GetTexcoords( sd, positionWS, ndc, false );
+}
+
+uint2 EvalShadow_GetTexcoords( ShadowData sd, float3 positionWS, out float2 closestSampleNDC )
+{
+	float4 posCS = mul( float4( positionWS, 1.0 ), sd.worldToShadow );
+	float2 posNDC = posCS.xy / posCS.w;
+	// calc TCs
+	float2 posTC = posNDC * 0.5 + 0.5;
+	closestSampleNDC = (floor(posTC * sd.textureSize.zw) + 0.5) * sd.texelSizeRcp.zw * 2.0 - 1.0.xx;
+	return (posTC * sd.scaleOffset.xy + sd.scaleOffset.zw) * sd.textureSize.xy;
 }
 
 int EvalShadow_GetCubeFaceID( float3 dir )
 	float slice;
 	UnpackShadowmapId( sd.id, texIdx, sampIdx, slice );
 	UnpackShadowType( sd.shadowType, shadowType, shadowAlgorithm );
-	return SampleShadow_SelectAlgorithm(shadowContext, sd, payloadOffset, posTC, sd.bias, slice, shadowAlgorithm, texIdx, sampIdx);
+	return SampleShadow_SelectAlgorithm( shadowContext, sd, payloadOffset, posTC, sd.bias, slice, shadowAlgorithm, texIdx, sampIdx );
 }
 
 #define EvalShadow_PunctualDepth_( _samplerType )																																		\
 //
 //	Directional shadows (cascaded shadow map)
 //
-int EvalShadow_GetSplitSphereIndexForDirshadows( float3 positionWS, float4 dirShadowSplitSpheres[4] )
+
+#define kMaxShadowCascades 4
+
+int EvalShadow_GetSplitSphereIndexForDirshadows( float3 positionWS, float4 dirShadowSplitSpheres[4], out float relDistance )
 {
 	float3 fromCenter0 = positionWS.xyz - dirShadowSplitSpheres[0].xyz;
 	float3 fromCenter1 = positionWS.xyz - dirShadowSplitSpheres[1].xyz;
 	weights.yzw = saturate( weights.yzw - weights.xyz );
 
 	int idx = int( 4.0 - dot( weights, float4( 4.0, 3.0, 2.0, 1.0 ) ) );
+	relDistance = distances2[idx] / dirShadowSplitSphereSqRadii[idx];
+int EvalShadow_GetSplitSphereIndexForDirshadows( float3 positionWS, float4 dirShadowSplitSpheres[4] )
+{
+	float relDist;
+	return EvalShadow_GetSplitSphereIndexForDirshadows( positionWS, dirShadowSplitSpheres, relDist );
+}
+
 uint EvalShadow_LoadSplitSpheres( ShadowContext shadowContext, int index, out float4 splitSpheres[4] )
 {
 	uint offset = GetPayloadOffset( shadowContext.shadowDatas[index] );
 	return offset + 4;
 }
 
-float EvalShadow_CascadedDepth( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int index, float3 L )
+float EvalShadow_CascadedDepth_Blend( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int index, float3 L )
-	ShadowData sd = shadowContext.shadowDatas[index];
+	// load the right shadow data for the current face
+	float4 dirShadowSplitSpheres[4];
+	uint payloadOffset = EvalShadow_LoadSplitSpheres( shadowContext, index, dirShadowSplitSpheres );
+	float relDistance;
+	int shadowSplitIndex = EvalShadow_GetSplitSphereIndexForDirshadows( positionWS, dirShadowSplitSpheres, relDistance );
+	if( shadowSplitIndex < 0 )
+		return 1.0;
+
+	float4 scales = asfloat( shadowContext.payloads[payloadOffset] );
+	payloadOffset++;
+	float4 borders = asfloat( shadowContext.payloads[payloadOffset] );
+	payloadOffset++;
+
+	ShadowData sd = shadowContext.shadowDatas[index + 1 + shadowSplitIndex];
-	positionWS += EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L ) ), sd.texelSizeRcp.zw, sd.normalBias );
+	float3 orig_pos = positionWS;
+	uint orig_payloadOffset = payloadOffset;
+	positionWS += EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L ) ), scales[shadowSplitIndex] * sd.texelSizeRcp.zw, sd.normalBias );
+	// get shadowmap texcoords
+	float3 posNDC;
+	float3 posTC = EvalShadow_GetTexcoords( sd, positionWS, posNDC, true );
+	// sample the texture
+	uint texIdx, sampIdx;
+	float slice;
+	UnpackShadowmapId( sd.id, texIdx, sampIdx, slice );
+
+	uint shadowType, shadowAlgorithm;
+	UnpackShadowType( sd.shadowType, shadowType, shadowAlgorithm );
+	float shadow = SampleShadow_SelectAlgorithm( shadowContext, sd, payloadOffset, posTC, sd.bias, slice, shadowAlgorithm, texIdx, sampIdx );
+
+	float border = borders[shadowSplitIndex];
+	float alpha  = border <= 0.0 ? 0.0 : saturate( (relDistance - (1.0 - border)) / border );
+
+	shadowSplitIndex++;
+	float shadow1 = 1.0;
+	if( shadowSplitIndex < kMaxShadowCascades )
+	{
+		float4 splitSphere = dirShadowSplitSpheres[shadowSplitIndex - 1];
+		float3 cascadeDir  = normalize( -splitSphere.xyz + dirShadowSplitSpheres[shadowSplitIndex].xyz );
+		float3 wposDir     = normalize( -splitSphere.xyz + positionWS );
+		float  cascDot     = dot( cascadeDir, wposDir );
+		alpha   = cascDot > 0.0 ? alpha : lerp( alpha, 0.0, saturate( -cascDot * 4.0 ) );
+		shadow1 = shadow;
+
+		[branch]
+		if( alpha > 0.0 )
+		{
+			sd = shadowContext.shadowDatas[index + 1 + shadowSplitIndex];
+			positionWS = orig_pos + EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L ) ), scales[shadowSplitIndex] * sd.texelSizeRcp.zw, sd.normalBias );
+			posTC = EvalShadow_GetTexcoords( sd, positionWS, posNDC, false );
+			// sample the texture
+			UnpackShadowmapId( sd.id, slice );
+
+			if( all( abs( posNDC.xy ) <= (1.0 - sd.texelSizeRcp.zw * 0.5) ) )
+				shadow1 = SampleShadow_SelectAlgorithm( shadowContext, sd, orig_payloadOffset, posTC, sd.bias, slice, shadowAlgorithm, texIdx, sampIdx );
+		}
+	}
+	shadow = lerp( shadow, shadow1, alpha );
+	return shadow;
+}
+
+#define EvalShadow_CascadedDepth_( _samplerType ) 																																		        \
+	float EvalShadow_CascadedDepth_Blend( ShadowContext shadowContext, uint shadowAlgorithm, Texture2DArray tex, _samplerType samp, float3 positionWS, float3 normalWS, int index, float3 L )   \
+	{																																													        \
+		/* load the right shadow data for the current face */																															        \
+		float4 dirShadowSplitSpheres[kMaxShadowCascades];																																        \
+		uint payloadOffset = EvalShadow_LoadSplitSpheres( shadowContext, index, dirShadowSplitSpheres );																				        \
+		float relDistance;                                                                                                                                                                      \
+		int shadowSplitIndex = EvalShadow_GetSplitSphereIndexForDirshadows( positionWS, dirShadowSplitSpheres, relDistance );															        \
+		if( shadowSplitIndex < 0 )                                                                                                                                                              \
+			return 1.0;                                                                                                                                                                         \
+																																																\
+		float4 scales = asfloat( shadowContext.payloads[payloadOffset] );                                                                                                                       \
+		payloadOffset++;                                                                                                                                                                        \
+		float4 borders = asfloat( shadowContext.payloads[payloadOffset] );                                                                                                                      \
+		payloadOffset++;                                                                                                                                                                        \
+																																																\
+		ShadowData sd = shadowContext.shadowDatas[index + 1 + shadowSplitIndex];																										        \
+		/* normal based bias */																																							        \
+		float3 orig_pos = positionWS;                                                                                                                                                           \
+		uint   orig_payloadOffset = payloadOffset;		                                                                                                                                        \
+		positionWS += EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L ) ), scales[shadowSplitIndex] * sd.texelSizeRcp.zw, sd.normalBias );									        \
+		/* get shadowmap texcoords */																																					        \
+		float3 posNDC;                                                                                                                                                                          \
+		float3 posTC = EvalShadow_GetTexcoords( sd, positionWS, posNDC, true );																											        \
+		/* sample the texture */																																						        \
+		float slice;																																									        \
+		UnpackShadowmapId( sd.id, slice );																																				        \
+																																																\
+		float shadow = SampleShadow_SelectAlgorithm( shadowContext, sd, payloadOffset, posTC, sd.bias, slice, shadowAlgorithm, tex, samp );                                                     \
+																																																\
+		float border = borders[shadowSplitIndex];                                                                                                                                               \
+		float alpha  = border <= 0.0 ? 0.0 : saturate( (relDistance - (1.0 - border)) / border );                                                                                               \
+																																																\
+		shadowSplitIndex++;                                                                                                                                                                     \
+		float shadow1 = 1.0;                                                                                                                                                                    \
+		if( shadowSplitIndex < kMaxShadowCascades )                                                                                                                                             \
+		{                                                                                                                                                                                       \
+			float4 splitSphere = dirShadowSplitSpheres[shadowSplitIndex - 1];                                                                                                                   \
+			float3 cascadeDir  = normalize( -splitSphere.xyz + dirShadowSplitSpheres[shadowSplitIndex].xyz );                                                                                   \
+			float3 wposDir     = normalize( -splitSphere.xyz + positionWS );                                                                                                                    \
+			float  cascDot     = dot( cascadeDir, wposDir );                                                                                                                                    \
+			alpha   = cascDot > 0.0 ? alpha : lerp( alpha, 0.0, saturate( -cascDot * 4.0 ) );                                                                                                   \
+			shadow1 = shadow;                                                                                                                                                                   \
+																																																\
+			[branch]                                                                                                                                                                            \
+			if( alpha > 0.0 )                                                                                                                                                                   \
+			{                                                                                                                                                                                   \
+				sd = shadowContext.shadowDatas[index + 1 + shadowSplitIndex];																										            \
+				positionWS = orig_pos + EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L ) ), scales[shadowSplitIndex] * sd.texelSizeRcp.zw, sd.normalBias );				        \
+				posTC = EvalShadow_GetTexcoords( sd, positionWS, posNDC, false );																										        \
+				/* sample the texture */																																				        \
+				UnpackShadowmapId( sd.id, slice );																																		        \
+																																																\
+				if( all( abs( posNDC.xy ) <= (1.0 - sd.texelSizeRcp.zw * 0.5) ) )                                                                                                               \
+					shadow1 = SampleShadow_SelectAlgorithm( shadowContext, sd, orig_payloadOffset, posTC, sd.bias, slice, shadowAlgorithm, tex, samp );                                         \
+			}                                                                                                                                                                                   \
+		}                                                                                                                                                                                       \
+		shadow = lerp( shadow, shadow1, alpha );                                                                                                                                                \
+		return shadow;                                                                                                                                                                          \
+	}
+	EvalShadow_CascadedDepth_( SamplerComparisonState )
+	EvalShadow_CascadedDepth_( SamplerState )
+#undef EvalShadow_CascadedDepth_
+
+float EvalShadow_hash12( float2 pos )
+{
+	float3 p3  = frac( pos.xyx * float3( 443.8975, 397.2973, 491.1871 ) );
+		   p3 += dot( p3, p3.yzx + 19.19 );
+	return frac( (p3.x + p3.y) * p3.z );
+}
+
+float EvalShadow_CascadedDepth_Dither( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int index, float3 L )
+{
-	int shadowSplitIndex = EvalShadow_GetSplitSphereIndexForDirshadows( positionWS, dirShadowSplitSpheres );
+	float relDistance;
+	int shadowSplitIndex = EvalShadow_GetSplitSphereIndexForDirshadows( positionWS, dirShadowSplitSpheres, relDistance );
-	sd = shadowContext.shadowDatas[index + 1 + shadowSplitIndex];
+	float4 scales = asfloat( shadowContext.payloads[payloadOffset] );
+	payloadOffset++;
+	float4 borders = asfloat( shadowContext.payloads[payloadOffset] );
+	payloadOffset++;
+	float border = borders[shadowSplitIndex];
+	float alpha  = border <= 0.0 ? 0.0 : saturate( (relDistance - (1.0 - border)) / border );
+
+	ShadowData sd = shadowContext.shadowDatas[index + 1 + shadowSplitIndex];
+	// normal based bias
+	float3 orig_pos = positionWS;
+	positionWS += EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L ) ), scales[shadowSplitIndex] * sd.texelSizeRcp.zw, sd.normalBias );
-	float3 posTC = EvalShadow_GetTexcoords( sd, positionWS );
+	float3 posNDC;
+	float3 posTC = EvalShadow_GetTexcoords( sd, positionWS, posNDC, true );
+
+	if( shadowSplitIndex < (kMaxShadowCascades-1) )
+	{
+		float4 splitSphere = dirShadowSplitSpheres[shadowSplitIndex];
+		float3 cascadeDir  = normalize( -splitSphere.xyz + dirShadowSplitSpheres[shadowSplitIndex+1].xyz );
+		float3 wposDir     = normalize( -splitSphere.xyz + positionWS );
+		float  cascDot     = dot( cascadeDir, wposDir );
+		alpha = cascDot > 0.0 ? alpha : lerp( alpha, 0.0, saturate( -cascDot * 4.0 ) );
+		if( step( EvalShadow_hash12( posTC.xy ), alpha ) )
+		{
+			shadowSplitIndex++;
+			sd         = shadowContext.shadowDatas[index + 2 + shadowSplitIndex];
+			positionWS = orig_pos + EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L ) ), scales[shadowSplitIndex+1] * sd.texelSizeRcp.zw, sd.normalBias );
+			posTC      = EvalShadow_GetTexcoords( sd, positionWS );
+		}
+	}
 	// sample the texture
 	uint texIdx, sampIdx;
 	float slice;
 	UnpackShadowType( sd.shadowType, shadowType, shadowAlgorithm );
 
-	return SampleShadow_SelectAlgorithm( shadowContext, sd, payloadOffset, posTC, sd.bias, slice, shadowAlgorithm, texIdx, sampIdx );
+	float shadow = SampleShadow_SelectAlgorithm( shadowContext, sd, payloadOffset, posTC, sd.bias, slice, shadowAlgorithm, texIdx, sampIdx );
+	return shadowSplitIndex < (kMaxShadowCascades-1) ? shadow : lerp( shadow, 1.0, alpha );
-#define EvalShadow_CascadedDepth_( _samplerType ) 																																		\
-	float EvalShadow_CascadedDepth( ShadowContext shadowContext, uint shadowAlgorithm, Texture2DArray tex, _samplerType samp, float3 positionWS, float3 normalWS, int index, float3 L ) \
-	{																																													\
-		ShadowData sd = shadowContext.shadowDatas[index];																										                        \
-		/* normal based bias */																																							\
-		positionWS += EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L ) ), sd.texelSizeRcp.zw, sd.normalBias );															    \
-																																														\
-		/* load the right shadow data for the current face */																															\
-		float4 dirShadowSplitSpheres[4];																																				\
-		uint payloadOffset = EvalShadow_LoadSplitSpheres( shadowContext, index, dirShadowSplitSpheres );																				\
-		int shadowSplitIndex = EvalShadow_GetSplitSphereIndexForDirshadows( positionWS, dirShadowSplitSpheres );																		\
-		if( shadowSplitIndex < 0 )                                                                                                                                                      \
-			return 1.0;                                                                                                                                                                 \
-																																														\
-		sd = shadowContext.shadowDatas[index + 1 + shadowSplitIndex];																										            \
-		/* get shadowmap texcoords */																																					\
-		float3 posTC = EvalShadow_GetTexcoords( sd, positionWS );																														\
-		/* sample the texture */																																						\
-		float slice;																																									\
-		UnpackShadowmapId( sd.id, slice );																																				\
-																																														\
-		return SampleShadow_SelectAlgorithm( shadowContext, sd, payloadOffset, posTC, sd.bias, slice, shadowAlgorithm, tex, samp );														\
+#define EvalShadow_CascadedDepth_( _samplerType ) 																																		        \
+	float EvalShadow_CascadedDepth_Dither( ShadowContext shadowContext, uint shadowAlgorithm, Texture2DArray tex, _samplerType samp, float3 positionWS, float3 normalWS, int index, float3 L )  \
+	{																																													        \
+		/* load the right shadow data for the current face */																															        \
+		float4 dirShadowSplitSpheres[kMaxShadowCascades];																																        \
+		uint payloadOffset = EvalShadow_LoadSplitSpheres( shadowContext, index, dirShadowSplitSpheres );																				        \
+		float relDistance;                                                                                                                                                                      \
+		int shadowSplitIndex = EvalShadow_GetSplitSphereIndexForDirshadows( positionWS, dirShadowSplitSpheres, relDistance );															        \
+		if( shadowSplitIndex < 0 )                                                                                                                                                              \
+			return 1.0;                                                                                                                                                                         \
+																																																\
+		float4 scales = asfloat( shadowContext.payloads[payloadOffset] );                                                                                                                       \
+		payloadOffset++;                                                                                                                                                                        \
+		float4 borders = asfloat( shadowContext.payloads[payloadOffset] );                                                                                                                      \
+		payloadOffset++;                                                                                                                                                                        \
+		float border = borders[shadowSplitIndex];                                                                                                                                               \
+		float alpha  = border <= 0.0 ? 0.0 : saturate( (relDistance - (1.0 - border)) / border );                                                                                               \
+																																																\
+		ShadowData sd = shadowContext.shadowDatas[index + 1 + shadowSplitIndex];																										        \
+		/* normal based bias */																																							        \
+		float3 orig_pos = positionWS;                                                                                                                                                           \
+		positionWS += EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L ) ), scales[shadowSplitIndex] * sd.texelSizeRcp.zw, sd.normalBias );									        \
+		/* get shadowmap texcoords */																																					        \
+		float3 posNDC;                                                                                                                                                                          \
+		float3 posTC = EvalShadow_GetTexcoords( sd, positionWS, posNDC, true );																											        \
+																																																\
+		if( shadowSplitIndex < (kMaxShadowCascades-1) )                                                                                                                                         \
+		{                                                                                                                                                                                       \
+			float4 splitSphere = dirShadowSplitSpheres[shadowSplitIndex];                                                                                                                       \
+			float3 cascadeDir  = normalize( -splitSphere.xyz + dirShadowSplitSpheres[shadowSplitIndex+1].xyz );                                                                                 \
+			float3 wposDir     = normalize( -splitSphere.xyz + positionWS );                                                                                                                    \
+			float  cascDot     = dot( cascadeDir, wposDir );                                                                                                                                    \
+			alpha = cascDot > 0.0 ? alpha : lerp( alpha, 0.0, saturate( -cascDot * 4.0 ) );                                                                                                     \
+																																																\
+			if( step( EvalShadow_hash12( posTC.xy ), alpha ) )                                                                                                                                  \
+			{                                                                                                                                                                                   \
+				sd         = shadowContext.shadowDatas[index + 2 + shadowSplitIndex];                                                                                                           \
+				positionWS = orig_pos + EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L ) ), scales[shadowSplitIndex+1] * sd.texelSizeRcp.zw, sd.normalBias );				        \
+				posTC      = EvalShadow_GetTexcoords( sd, positionWS );                                                                                                                         \
+			}                                                                                                                                                                                   \
+		}                                                                                                                                                                                       \
+		/* sample the texture */																																						        \
+		float  slice;																																									        \
+		UnpackShadowmapId( sd.id, slice );																																				        \
+		float shadow = SampleShadow_SelectAlgorithm( shadowContext, sd, payloadOffset, posTC, sd.bias, slice, shadowAlgorithm, tex, samp );                                                     \
+		return shadowSplitIndex < (kMaxShadowCascades-1) ? shadow : lerp( shadow, 1.0, alpha );                                                                                                 \
+
+
+//------------------------------------------------------------------------------------------------------------------------------------
+
+float3 EvalShadow_GetClosestSample_Point( ShadowContext shadowContext, float3 positionWS, int index, float3 L )
+{
+	// get the algorithm
+	ShadowData sd = shadowContext.shadowDatas[index];
+	// load the right shadow data for the current face
+	int faceIndex = EvalShadow_GetCubeFaceID( L ) + 1;
+	sd = shadowContext.shadowDatas[index + faceIndex];
+
+	float4 closestNDC = { 0,0,0,1 };
+	uint2 texelIdx = EvalShadow_GetTexcoords( sd, positionWS, closestNDC.xy );
+
+	// load the texel
+	uint texIdx, sampIdx;
+	float slice;
+	UnpackShadowmapId( sd.id, texIdx, sampIdx, slice );
+	closestNDC.z = LoadShadow_T2DA( shadowContext, texIdx, texelIdx, slice );
+
+	// reconstruct depth position
+	float4 closestWS = mul( closestNDC, sd.shadowToWorld );
+	return closestWS.xyz / closestWS.w;
+}
+
+
+float3 EvalShadow_GetClosestSample_Point( ShadowContext shadowContext, Texture2DArray tex, float3 positionWS, int index, float3 L )
+{
+	// get the algorithm
+	ShadowData sd = shadowContext.shadowDatas[index];
+	// load the right shadow data for the current face
+	int faceIndex = EvalShadow_GetCubeFaceID( L ) + 1;
+	sd = shadowContext.shadowDatas[index + faceIndex];
+
+	float4 closestNDC = { 0,0,0,1 };
+	uint2 texelIdx = EvalShadow_GetTexcoords( sd, positionWS, closestNDC.xy );
+
+	// load the texel
+	float slice;
+	UnpackShadowmapId(sd.id, slice);
+	closestNDC.z = LOAD_TEXTURE2D_ARRAY_LOD( tex, texelIdx, slice, 0 ).x;
+
+	// reconstruct depth position
+	float4 closestWS = mul( closestNDC, sd.shadowToWorld );
+	return closestWS.xyz / closestWS.w;
+}
+
+float3 EvalShadow_GetClosestSample_Spot( ShadowContext shadowContext, float3 positionWS, int index )
+{
+	// get the algorithm
+	ShadowData sd = shadowContext.shadowDatas[index];
+
+	float4 closestNDC = { 0,0,0,1 };
+	uint2 texelIdx = EvalShadow_GetTexcoords( sd, positionWS, closestNDC.xy );
+
+	// load the texel
+	uint texIdx, sampIdx;
+	float slice;
+	UnpackShadowmapId( sd.id, texIdx, sampIdx, slice );
+	closestNDC.z = LoadShadow_T2DA( shadowContext, texIdx, texelIdx, slice );
+
+	// reconstruct depth position
+	float4 closestWS = mul( closestNDC, sd.shadowToWorld );
+	return closestWS.xyz / closestWS.w;
+}
+
+
+float3 EvalShadow_GetClosestSample_Spot( ShadowContext shadowContext, Texture2DArray tex, float3 positionWS, int index )
+{
+	// get the algorithm
+	ShadowData sd = shadowContext.shadowDatas[index];
+
+	float4 closestNDC = { 0,0,0,1 };
+	uint2 texelIdx = EvalShadow_GetTexcoords( sd, positionWS, closestNDC.xy );
+
+	// load the texel
+	float slice;
+	UnpackShadowmapId(sd.id, slice);
+	closestNDC.z = LOAD_TEXTURE2D_ARRAY_LOD( tex, texelIdx, slice, 0 ).x;
+
+	// reconstruct depth position
+	float4 closestWS = mul( closestNDC, sd.shadowToWorld );
+	return closestWS.xyz / closestWS.w;
+}
+
+float3 EvalShadow_GetClosestSample_Punctual( ShadowContext shadowContext, float3 positionWS, int index, float3 L )
+{
+	// get the algorithm
+	ShadowData sd = shadowContext.shadowDatas[index];
+	uint shadowType;
+	UnpackShadowType( sd.shadowType, shadowType );
+	// load the right shadow data for the current face
+	int faceIndex = shadowType == GPUSHADOWTYPE_POINT ? (EvalShadow_GetCubeFaceID( L ) + 1) : 0;
+	sd = shadowContext.shadowDatas[index + faceIndex];
+
+	float4 closestNDC = { 0,0,0,1 };
+	uint2 texelIdx = EvalShadow_GetTexcoords( sd, positionWS, closestNDC.xy );
+
+	// load the texel
+	uint texIdx, sampIdx;
+	float slice;
+	UnpackShadowmapId( sd.id, texIdx, sampIdx, slice );
+	closestNDC.z = LoadShadow_T2DA( shadowContext, texIdx, texelIdx, slice );
+
+	// reconstruct depth position
+	float4 closestWS = mul( closestNDC, sd.shadowToWorld );
+	return closestWS.xyz / closestWS.w;
+}
+
+float3 EvalShadow_GetClosestSample_Punctual( ShadowContext shadowContext, Texture2DArray tex, float3 positionWS, int index, float3 L )
+{
+	// get the algorithm
+	ShadowData sd = shadowContext.shadowDatas[index];
+	uint shadowType;
+	UnpackShadowType( sd.shadowType, shadowType );
+	// load the right shadow data for the current face
+	int faceIndex = shadowType == GPUSHADOWTYPE_POINT ? (EvalShadow_GetCubeFaceID( L ) + 1) : 0;
+	sd = shadowContext.shadowDatas[index + faceIndex];
+
+	float4 closestNDC = { 0,0,0,1 };
+	uint2 texelIdx = EvalShadow_GetTexcoords( sd, positionWS, closestNDC.xy );
+
+	// load the texel
+	float slice;
+	UnpackShadowmapId(sd.id, slice);
+	closestNDC.z = LOAD_TEXTURE2D_ARRAY_LOD( tex, texelIdx, slice, 0 ).x;
+
+	// reconstruct depth position
+	float4 closestWS = mul( closestNDC, sd.shadowToWorld );
+	return closestWS.xyz / closestWS.w;
+}
+
+float3 EvalShadow_GetClosestSample_Cascade( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int index, float4 L )
+{
+	// load the right shadow data for the current face
+	float4 dirShadowSplitSpheres[4];
+	uint payloadOffset = EvalShadow_LoadSplitSpheres( shadowContext, index, dirShadowSplitSpheres );
+	float relDistance;
+	int shadowSplitIndex = EvalShadow_GetSplitSphereIndexForDirshadows( positionWS, dirShadowSplitSpheres, relDistance );
+	if( shadowSplitIndex < 0 )
+		return 1.0;
+
+	float4 scales = asfloat( shadowContext.payloads[payloadOffset] );
+	payloadOffset++;
+	float4 borders = asfloat( shadowContext.payloads[payloadOffset] );
+	payloadOffset++;
+
+	ShadowData sd = shadowContext.shadowDatas[index + 1 + shadowSplitIndex];
+
+	float4 closestNDC = { 0,0,0,1 };
+	uint2 texelIdx = EvalShadow_GetTexcoords( sd, positionWS, closestNDC.xy );
+
+	// load the texel
+	uint texIdx, sampIdx;
+	float slice;
+	UnpackShadowmapId( sd.id, texIdx, sampIdx, slice );
+	closestNDC.z = LoadShadow_T2DA( shadowContext, texIdx, texelIdx, slice );
+
+	// reconstruct depth position
+	float4 closestWS = mul( closestNDC, sd.shadowToWorld );
+	return closestWS.xyz / closestWS.w;
+}

Assets/ScriptableRenderPipeline/ShaderLibrary/Shadow/ShadowTexFetch.hlsl

 // Shader model >= 5.1
 #	define SHADOW_DEFINE_SAMPLING_FUNC_T2DA_COMP( _Tex2DArraySlots  , _SamplerCompSlots )	float4 SampleCompShadow_T2DA( ShadowContext ctxt, uint texIdx, uint sampIdx, float3 tcs, float slice					)	{ return SAMPLE_TEXTURE2D_ARRAY_SHADOW( ctxt.tex2DArray[texIdx], ctxt.compSamplers[sampIdx], tcs, slice );		}
 #	define SHADOW_DEFINE_SAMPLING_FUNC_T2DA_SAMP( _Tex2DArraySlots  , _SamplerSlots )		float4 SampleShadow_T2DA(	  ShadowContext ctxt, uint texIdx, uint sampIdx, float2 tcs, float slice, float lod = 0.0	)	{ return SAMPLE_TEXTURE2D_ARRAY_LOD( ctxt.tex2DArray[texIdx], ctxt.samplers[sampIdx], tcs, slice, lod );		}
+#   define SHADOW_DEFINE_SAMPLING_FUNC_T2DA_LOAD( _Tex2DArraySlots  )	                    float4 LoadShadow_T2DA(	      ShadowContext ctxt, uint texIdx,               uint2  tcs, uint  slice, uint lod = 0	    )   { return LOAD_TEXTURE2D_ARRAY_LOD( ctxt.tex2DArray[texIdx], tcs, slice, lod ).x;                                }
 #	define SHADOW_DEFINE_SAMPLING_FUNC_TCA_COMP(  _TexCubeArraySlots, _SamplerCompSlots )	float4 SampleCompShadow_TCA(  ShadowContext ctxt, uint texIdx, uint sampIdx, float4 tcs, float cubeIdx					)	{ return SAMPLE_TEXTURECUBE_ARRAY_SHADOW( ctxt.texCubeArray[texIdx], ctxt.compSamplers[sampIdx], tcs, cubeIdx );}
 #	define SHADOW_DEFINE_SAMPLING_FUNC_TCA_SAMP(  _TexCubeArraySlots, _SamplerSlots )		float4 SampleShadow_TCA(	  ShadowContext ctxt, uint texIdx, uint sampIdx, float3 tcs, float cubeIdx, float lod = 0.0 )	{ return SAMPLE_TEXTURECUBE_ARRAY_LOD( ctxt.texCubeArray[texIdx], ctxt.samplers[sampIdx], tcs, cubeIdx, lod );	}
 
 			return res;																											\
 		}
 
+#	define SHADOW_DEFINE_SAMPLING_FUNC_T2DA_LOAD( _Tex2DArraySlots )												            \
+		float LoadShadow_T2DA( ShadowContext ctxt, uint texIdx, uint2 tcs, uint slice, uint lod = 0 )		                    \
+		{																														\
+			float res = 1.0;																								    \
+			[unroll] for( uint i = 0; i < _Tex2DArraySlots; i++ )																\
+			{																													\
+				[branch] if( i == texIdx )																	                    \
+				{																											    \
+					res = LOAD_TEXTURE2D_ARRAY_LOD( ctxt.tex2DArray[i], tcs, slice, lod ).x;				                    \
+					break;																									    \
+				}																											    \
+			}																													\
+			return res;																											\
+		}
+
+
 #	define SHADOW_DEFINE_SAMPLING_FUNC_TCA_COMP( _TexCubeArraySlots, _SamplerCompSlots )										\
 		float4 SampleCompShadow_TCA( ShadowContext ctxt, uint texIdx, uint sampIdx, float4 tcs, float cubeIdx )					\
 		{																														\
 // helper macro to suppress code generation if _cnt is 0
 #define SHADOW_DECLARE_SAMPLING_FUNC_T2DA_COMP( _Tex2DArraySlots  , _SamplerCompSlots )	float4 SampleCompShadow_T2DA( ShadowContext ctxt, uint texIdx, uint sampIdx, float3 tcs, float slice					);
 #define SHADOW_DECLARE_SAMPLING_FUNC_T2DA_SAMP( _Tex2DArraySlots  , _SamplerSlots )		float4 SampleShadow_T2DA(	  ShadowContext ctxt, uint texIdx, uint sampIdx, float2 tcs, float slice, float lod = 0.0	);
+#define SHADOW_DECLARE_SAMPLING_FUNC_T2DA_LOAD( _Tex2DArraySlots  )	                    float4 LoadShadow_T2DA(	      ShadowContext ctxt, uint texIdx,               uint2  tcs, uint  slice, uint lod = 0	    );
 #define SHADOW_DECLARE_SAMPLING_FUNC_TCA_COMP(  _TexCubeArraySlots, _SamplerCompSlots )	float4 SampleCompShadow_TCA(  ShadowContext ctxt, uint texIdx, uint sampIdx, float4 tcs, float cubeIdx					);
 #define SHADOW_DECLARE_SAMPLING_FUNC_TCA_SAMP(  _TexCubeArraySlots, _SamplerSlots )		float4 SampleShadow_TCA(	  ShadowContext ctxt, uint texIdx, uint sampIdx, float3 tcs, float cubeIdx, float lod = 0.0 );
 
 #define SHADOW_DEFINE_SAMPLING_FUNCS( _Tex2DArraySlots, _TexCubeArraySlots, _SamplerCompSlots, _SamplerSlots )	\
 	SHADOW_CHECK( _Tex2DArraySlots  , SHADOW_CHECK_ALT( _SamplerCompSlots, SHADOW_DEFINE_SAMPLING_FUNC_T2DA_COMP( _Tex2DArraySlots, _SamplerCompSlots ), SHADOW_DECLARE_SAMPLING_FUNC_T2DA_COMP( _Tex2DArraySlots, _SamplerCompSlots ) ) )	\
 	SHADOW_CHECK( _Tex2DArraySlots  , SHADOW_CHECK_ALT( _SamplerSlots    , SHADOW_DEFINE_SAMPLING_FUNC_T2DA_SAMP( _Tex2DArraySlots, _SamplerSlots     ), SHADOW_DECLARE_SAMPLING_FUNC_T2DA_SAMP( _Tex2DArraySlots, _SamplerSlots     ) ) )	\
+									  SHADOW_CHECK_ALT( _Tex2DArraySlots , SHADOW_DEFINE_SAMPLING_FUNC_T2DA_LOAD( _Tex2DArraySlots                    ), SHADOW_DECLARE_SAMPLING_FUNC_T2DA_LOAD( _Tex2DArraySlots                    ) )	\
 	SHADOW_CHECK( _TexCubeArraySlots, SHADOW_CHECK_ALT( _SamplerCompSlots, SHADOW_DEFINE_SAMPLING_FUNC_TCA_COMP(_TexCubeArraySlots, _SamplerCompSlots ), SHADOW_DECLARE_SAMPLING_FUNC_TCA_COMP(_TexCubeArraySlots, _SamplerCompSlots ) ) )	\
 	SHADOW_CHECK( _TexCubeArraySlots, SHADOW_CHECK_ALT( _SamplerSlots    , SHADOW_DEFINE_SAMPLING_FUNC_TCA_SAMP(_TexCubeArraySlots, _SamplerSlots     ), SHADOW_DECLARE_SAMPLING_FUNC_TCA_SAMP(_TexCubeArraySlots, _SamplerSlots     ) ) )

Assets/TestScenes/HDTest/GraphicTest/SSS/Materials/SSSHead.mat

     - _SrcBlend: 1
     - _StencilRef: 1
     - _Stiffness: 1
-    - _SubsurfaceProfile: 0
+    - _SubsurfaceProfile: 4
     - _SubsurfaceRadius: 1
     - _SurfaceType: 0
     - _TexWorldScale: 1

Assets/TestScenes/HDTest/Material/HDRenderLoopMaterials/GGX Test/GGX_a02_s00.mat

     m_Floats:
     - _AlphaCutoff: 0.5
     - _AlphaCutoffEnable: 0
-    - _Anisotropy: 0
+    - _Anisotropy: 0.2
     - _BlendMode: 0
     - _BumpScale: 1
     - _CullMode: 2

ProjectSettings/DynamicsManager.asset

-%YAML 1.1
-%TAG !u! tag:unity3d.com,2011:
---- !u!55 &1
-PhysicsManager:
-  m_ObjectHideFlags: 0
-  m_Gravity: {x: 0, y: -9.81000042, z: 0}
-  m_DefaultMaterial: {fileID: 0}
-  m_BounceThreshold: 2
-  m_SleepThreshold: .00499999989
-  m_DefaultContactOffset: .00999999978
-  m_SolverIterationCount: 6
-  m_RaycastsHitTriggers: 1
-  m_EnableAdaptiveForce: 0
-  m_LayerCollisionMatrix: ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!55 &1
+PhysicsManager:
+  m_ObjectHideFlags: 0
+  serializedVersion: 3
+  m_Gravity: {x: 0, y: -9.81, z: 0}
+  m_DefaultMaterial: {fileID: 0}
+  m_BounceThreshold: 2
+  m_SleepThreshold: 0.005
+  m_DefaultContactOffset: 0.01
+  m_DefaultSolverIterations: 6
+  m_DefaultSolverVelocityIterations: 1
+  m_QueriesHitBackfaces: 0
+  m_QueriesHitTriggers: 1
+  m_EnableAdaptiveForce: 0
+  m_EnablePCM: 1
+  m_LayerCollisionMatrix: ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+  m_AutoSimulation: 1
+  m_AutoSyncTransforms: 1

ProjectSettings/ProjectSettings.asset

   androidBlitType: 0
   defaultIsFullScreen: 0
   defaultIsNativeResolution: 1
-  macRetinaSupport: 0
+  macRetinaSupport: 1
   runInBackground: 1
   captureSingleScreen: 0
   muteOtherAudioSources: 0
   allowFullscreenSwitch: 1
   graphicsJobMode: 0
   macFullscreenMode: 2
-  d3d9FullscreenMode: 1
   d3d11FullscreenMode: 1
   xboxSpeechDB: 0
   xboxEnableHeadOrientation: 0
   protectGraphicsMemory: 0
   useHDRDisplay: 0
   m_ColorGamuts: 00000000
-  targetPixelDensity: 0
+  targetPixelDensity: 30
   resolutionScalingMode: 0
   androidSupportedAspectRatio: 1
   androidMaxAspectRatio: 2.1
   webGLUseWasm: 0
   webGLCompressionFormat: 1
   scriptingDefineSymbols:
-    4: UNITY_POST_PROCESSING_STACK_V2
   platformArchitecture:
     iOS: 2
   scriptingBackend:

ProjectSettings/ProjectVersion.txt

-m_EditorVersion: 2017.3.0a2
+m_EditorVersion: 2017.3.0a3

Assets/ScriptableRenderPipeline/HDRenderPipeline/HDShaderIDs.cs

+namespace UnityEngine.Experimental.Rendering.HDPipeline
+{
+    // Pre-hashed shader ids - naming conventions are a bit off in this file as we use the same
+    // fields names as in the shaders for ease of use... Would be nice to clean this up at some
+    // point.
+    static class HDShaderIDs
+    {
+        internal static readonly int _ShadowDatasExp = Shader.PropertyToID("_ShadowDatasExp");
+        internal static readonly int _ShadowPayloads = Shader.PropertyToID("_ShadowPayloads");
+        internal static readonly int _ShadowmapExp_VSM_0 = Shader.PropertyToID("_ShadowmapExp_VSM_0");
+        internal static readonly int _ShadowmapExp_VSM_1 = Shader.PropertyToID("_ShadowmapExp_VSM_1");
+        internal static readonly int _ShadowmapExp_VSM_2 = Shader.PropertyToID("_ShadowmapExp_VSM_2");
+        internal static readonly int _ShadowmapExp_PCF = Shader.PropertyToID("_ShadowmapExp_PCF");
+
+        internal static readonly int g_LayeredSingleIdxBuffer = Shader.PropertyToID("g_LayeredSingleIdxBuffer");
+        internal static readonly int _EnvLightIndexShift = Shader.PropertyToID("_EnvLightIndexShift");
+        internal static readonly int g_iNrVisibLights = Shader.PropertyToID("g_iNrVisibLights");
+        internal static readonly int g_mScrProjection = Shader.PropertyToID("g_mScrProjection");
+        internal static readonly int g_mInvScrProjection = Shader.PropertyToID("g_mInvScrProjection");
+        internal static readonly int g_iLog2NumClusters = Shader.PropertyToID("g_iLog2NumClusters");
+        internal static readonly int g_fNearPlane = Shader.PropertyToID("g_fNearPlane");
+        internal static readonly int g_fFarPlane = Shader.PropertyToID("g_fFarPlane");
+        internal static readonly int g_fClustScale = Shader.PropertyToID("g_fClustScale");
+        internal static readonly int g_fClustBase = Shader.PropertyToID("g_fClustBase");
+        internal static readonly int g_depth_tex = Shader.PropertyToID("g_depth_tex");
+        internal static readonly int g_vLayeredLightList = Shader.PropertyToID("g_vLayeredLightList");
+        internal static readonly int g_LayeredOffset = Shader.PropertyToID("g_LayeredOffset");
+        internal static readonly int g_vBigTileLightList = Shader.PropertyToID("g_vBigTileLightList");
+        internal static readonly int g_logBaseBuffer = Shader.PropertyToID("g_logBaseBuffer");
+        internal static readonly int g_vBoundsBuffer = Shader.PropertyToID("g_vBoundsBuffer");
+        internal static readonly int _LightVolumeData = Shader.PropertyToID("_LightVolumeData");
+        internal static readonly int g_data = Shader.PropertyToID("g_data");
+        internal static readonly int g_mProjection = Shader.PropertyToID("g_mProjection");
+        internal static readonly int g_mInvProjection = Shader.PropertyToID("g_mInvProjection");
+        internal static readonly int g_viDimensions = Shader.PropertyToID("g_viDimensions");
+        internal static readonly int g_vLightList = Shader.PropertyToID("g_vLightList");
+
+        internal static readonly int g_BaseFeatureFlags = Shader.PropertyToID("g_BaseFeatureFlags");
+        internal static readonly int g_TileFeatureFlags = Shader.PropertyToID("g_TileFeatureFlags");
+
+        internal static readonly int _GBufferTexture0 = Shader.PropertyToID("_GBufferTexture0");
+        internal static readonly int _GBufferTexture1 = Shader.PropertyToID("_GBufferTexture1");
+        internal static readonly int _GBufferTexture2 = Shader.PropertyToID("_GBufferTexture2");
+        internal static readonly int _GBufferTexture3 = Shader.PropertyToID("_GBufferTexture3");
+
+        internal static readonly int g_DispatchIndirectBuffer = Shader.PropertyToID("g_DispatchIndirectBuffer");
+        internal static readonly int g_TileList = Shader.PropertyToID("g_TileList");
+        internal static readonly int g_NumTiles = Shader.PropertyToID("g_NumTiles");
+        internal static readonly int g_NumTilesX = Shader.PropertyToID("g_NumTilesX");
+
+        internal static readonly int _NumTiles = Shader.PropertyToID("_NumTiles");
+
+        internal static readonly int _CookieTextures = Shader.PropertyToID("_CookieTextures");
+        internal static readonly int _CookieCubeTextures = Shader.PropertyToID("_CookieCubeTextures");
+        internal static readonly int _EnvTextures = Shader.PropertyToID("_EnvTextures");
+        internal static readonly int _DirectionalLightDatas = Shader.PropertyToID("_DirectionalLightDatas");
+        internal static readonly int _DirectionalLightCount = Shader.PropertyToID("_DirectionalLightCount");
+        internal static readonly int _LightDatas = Shader.PropertyToID("_LightDatas");
+        internal static readonly int _PunctualLightCount = Shader.PropertyToID("_PunctualLightCount");
+        internal static readonly int _AreaLightCount = Shader.PropertyToID("_AreaLightCount");
+        internal static readonly int g_vLightListGlobal = Shader.PropertyToID("g_vLightListGlobal");
+        internal static readonly int _EnvLightDatas = Shader.PropertyToID("_EnvLightDatas");
+        internal static readonly int _EnvLightCount = Shader.PropertyToID("_EnvLightCount");
+        internal static readonly int _ShadowDatas = Shader.PropertyToID("_ShadowDatas");
+        internal static readonly int _DirShadowSplitSpheres = Shader.PropertyToID("_DirShadowSplitSpheres");
+        internal static readonly int _NumTileFtplX = Shader.PropertyToID("_NumTileFtplX");
+        internal static readonly int _NumTileFtplY = Shader.PropertyToID("_NumTileFtplY");
+        internal static readonly int _NumTileClusteredX = Shader.PropertyToID("_NumTileClusteredX");
+        internal static readonly int _NumTileClusteredY = Shader.PropertyToID("_NumTileClusteredY");
+
+        internal static readonly int g_isLogBaseBufferEnabled = Shader.PropertyToID("g_isLogBaseBufferEnabled");
+        internal static readonly int g_vLayeredOffsetsBuffer = Shader.PropertyToID("g_vLayeredOffsetsBuffer");
+
+        internal static readonly int _ViewTilesFlags = Shader.PropertyToID("_ViewTilesFlags");
+        internal static readonly int _MousePixelCoord = Shader.PropertyToID("_MousePixelCoord");
+
+        internal static readonly int _DebugViewMaterial = Shader.PropertyToID("_DebugViewMaterial");
+        internal static readonly int _DebugLightingMode = Shader.PropertyToID("_DebugLightingMode");
+        internal static readonly int _DebugLightingAlbedo = Shader.PropertyToID("_DebugLightingAlbedo");
+        internal static readonly int _DebugLightingSmoothness = Shader.PropertyToID("_DebugLightingSmoothness");
+        internal static readonly int _AmbientOcclusionTexture = Shader.PropertyToID("_AmbientOcclusionTexture");
+
+        internal static readonly int _UseTileLightList = Shader.PropertyToID("_UseTileLightList");
+        internal static readonly int _Time = Shader.PropertyToID("_Time");
+        internal static readonly int _SinTime = Shader.PropertyToID("_SinTime");
+        internal static readonly int _CosTime = Shader.PropertyToID("_CosTime");
+        internal static readonly int unity_DeltaTime = Shader.PropertyToID("unity_DeltaTime");
+        internal static readonly int _EnvLightSkyEnabled = Shader.PropertyToID("_EnvLightSkyEnabled");
+        internal static readonly int _AmbientOcclusionDirectLightStrenght = Shader.PropertyToID("_AmbientOcclusionDirectLightStrenght");
+        internal static readonly int _SkyTexture = Shader.PropertyToID("_SkyTexture");
+
+        internal static readonly int _EnableSSSAndTransmission = Shader.PropertyToID("_EnableSSSAndTransmission");
+        internal static readonly int _TexturingModeFlags = Shader.PropertyToID("_TexturingModeFlags");
+        internal static readonly int _TransmissionFlags = Shader.PropertyToID("_TransmissionFlags");
+        internal static readonly int _ThicknessRemaps = Shader.PropertyToID("_ThicknessRemaps");
+        internal static readonly int _ShapeParams = Shader.PropertyToID("_ShapeParams");
+        internal static readonly int _TransmissionTints = Shader.PropertyToID("_TransmissionTints");
+        internal static readonly int specularLightingUAV = Shader.PropertyToID("specularLightingUAV");
+        internal static readonly int diffuseLightingUAV = Shader.PropertyToID("diffuseLightingUAV");
+
+        internal static readonly int g_TileListOffset = Shader.PropertyToID("g_TileListOffset");
+
+        internal static readonly int _LtcData = Shader.PropertyToID("_LtcData");
+        internal static readonly int _PreIntegratedFGD = Shader.PropertyToID("_PreIntegratedFGD");
+        internal static readonly int _LtcGGXMatrix = Shader.PropertyToID("_LtcGGXMatrix");
+        internal static readonly int _LtcDisneyDiffuseMatrix = Shader.PropertyToID("_LtcDisneyDiffuseMatrix");
+        internal static readonly int _LtcMultiGGXFresnelDisneyDiffuse = Shader.PropertyToID("_LtcMultiGGXFresnelDisneyDiffuse");
+
+        internal static readonly int _MainDepthTexture = Shader.PropertyToID("_MainDepthTexture");
+
+        internal static readonly int unity_OrthoParams = Shader.PropertyToID("unity_OrthoParams");
+        internal static readonly int _ZBufferParams = Shader.PropertyToID("_ZBufferParams");
+        internal static readonly int _ScreenParams = Shader.PropertyToID("_ScreenParams");
+        internal static readonly int _ProjectionParams = Shader.PropertyToID("_ProjectionParams");
+        internal static readonly int _WorldSpaceCameraPos = Shader.PropertyToID("_WorldSpaceCameraPos");
+
+
+        internal static readonly int _StencilRef = Shader.PropertyToID("_StencilRef");
+        internal static readonly int _StencilCmp = Shader.PropertyToID("_StencilCmp");
+
+        internal static readonly int _SrcBlend = Shader.PropertyToID("_SrcBlend");
+        internal static readonly int _DstBlend = Shader.PropertyToID("_DstBlend");
+
+        internal static readonly int _HTile = Shader.PropertyToID("_HTile");
+        internal static readonly int _StencilTexture = Shader.PropertyToID("_StencilTexture");
+
+        internal static readonly int _ViewMatrix = Shader.PropertyToID("_ViewMatrix");
+        internal static readonly int _InvViewMatrix = Shader.PropertyToID("_InvViewMatrix");
+        internal static readonly int _ProjMatrix = Shader.PropertyToID("_ProjMatrix");
+        internal static readonly int _InvProjMatrix = Shader.PropertyToID("_InvProjMatrix");
+        internal static readonly int _NonJitteredViewProjMatrix = Shader.PropertyToID("_NonJitteredViewProjMatrix");
+        internal static readonly int _ViewProjMatrix = Shader.PropertyToID("_ViewProjMatrix");
+        internal static readonly int _InvViewProjMatrix = Shader.PropertyToID("_InvViewProjMatrix");
+        internal static readonly int _InvProjParam = Shader.PropertyToID("_InvProjParam");
+        internal static readonly int _ScreenSize = Shader.PropertyToID("_ScreenSize");
+        internal static readonly int _PrevViewProjMatrix = Shader.PropertyToID("_PrevViewProjMatrix");
+        internal static readonly int _FrustumPlanes = Shader.PropertyToID("_FrustumPlanes");
+
+
+        internal static readonly int _CameraColorTexture = Shader.PropertyToID("_CameraColorTexture");
+        internal static readonly int _CameraDiffuseIrradianceTexture = Shader.PropertyToID("_CameraDiffuseIrradianceTexture");
+        internal static readonly int _CameraFilteringBuffer = Shader.PropertyToID("_CameraFilteringBuffer");
+        internal static readonly int _VelocityTexture = Shader.PropertyToID("_VelocityTexture");
+
+
+        internal static readonly int _DistortionTexture = Shader.PropertyToID("_DistortionTexture");
+        internal static readonly int _DebugFullScreenTexture = Shader.PropertyToID("_DebugFullScreenTexture");
+
+        internal static readonly int _WorldScales = Shader.PropertyToID("_WorldScales");
+        internal static readonly int _FilterKernels = Shader.PropertyToID("_FilterKernels");
+        internal static readonly int _DepthTexture = Shader.PropertyToID("_DepthTexture");
+        internal static readonly int _IrradianceSource = Shader.PropertyToID("_IrradianceSource");
+        internal static readonly int _FilterKernelsBasic = Shader.PropertyToID("_FilterKernelsBasic");
+        internal static readonly int _HalfRcpWeightedVariances = Shader.PropertyToID("_HalfRcpWeightedVariances");
+
+        internal static readonly int _CameraPosDiff = Shader.PropertyToID("_CameraPosDiff");
+
+        internal static readonly int _CameraDepthTexture = Shader.PropertyToID("_CameraDepthTexture");
+        internal static readonly int _CameraMotionVectorsTexture = Shader.PropertyToID("_CameraMotionVectorsTexture");
+        internal static readonly int _FullScreenDebugMode = Shader.PropertyToID("_FullScreenDebugMode");
+
+        internal static readonly int _InputCubemap = Shader.PropertyToID("_InputCubemap");
+        internal static readonly int _Mipmap = Shader.PropertyToID("_Mipmap");
+
+
+        internal static readonly int _MaxRadius = Shader.PropertyToID("_MaxRadius");
+        internal static readonly int _ShapeParam = Shader.PropertyToID("_ShapeParam");
+        internal static readonly int _StdDev1 = Shader.PropertyToID("_StdDev1");
+        internal static readonly int _StdDev2 = Shader.PropertyToID("_StdDev2");
+        internal static readonly int _LerpWeight = Shader.PropertyToID("_LerpWeight");
+        internal static readonly int _TransmissionTint = Shader.PropertyToID("_TransmissionTint");
+        internal static readonly int _ThicknessRemap = Shader.PropertyToID("_ThicknessRemap");
+
+        internal static readonly int _Cubemap = Shader.PropertyToID("_Cubemap");
+        internal static readonly int _SkyParam = Shader.PropertyToID("_SkyParam");
+    }
+}

Assets/ScriptableRenderPipeline/HDRenderPipeline/HDShaderIDs.cs.meta

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

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/Deferred.compute

+#pragma kernel Deferred_Direct_Fptl                          SHADE_OPAQUE_ENTRY=Deferred_Direct_Fptl                              USE_FPTL_LIGHTLIST
+#pragma kernel Deferred_Direct_Fptl_DebugDisplay             SHADE_OPAQUE_ENTRY=Deferred_Direct_Fptl_DebugDisplay                 USE_FPTL_LIGHTLIST        DEBUG_DISPLAY
+#pragma kernel Deferred_Direct_Clustered                     SHADE_OPAQUE_ENTRY=Deferred_Direct_Clustered                         USE_CLUSTERED_LIGHTLIST
+#pragma kernel Deferred_Direct_Clustered_DebugDisplay        SHADE_OPAQUE_ENTRY=Deferred_Direct_Clustered_DebugDisplay            USE_CLUSTERED_LIGHTLIST   DEBUG_DISPLAY
+
+#pragma kernel Deferred_Indirect_Fptl_Variant0               SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant0                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=0
+#pragma kernel Deferred_Indirect_Fptl_Variant1               SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant1                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=1
+#pragma kernel Deferred_Indirect_Fptl_Variant2               SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant2                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=2
+#pragma kernel Deferred_Indirect_Fptl_Variant3               SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant3                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=3
+#pragma kernel Deferred_Indirect_Fptl_Variant4               SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant4                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=4
+#pragma kernel Deferred_Indirect_Fptl_Variant5               SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant5                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=5
+#pragma kernel Deferred_Indirect_Fptl_Variant6               SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant6                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=6
+#pragma kernel Deferred_Indirect_Fptl_Variant7               SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant7                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=7
+#pragma kernel Deferred_Indirect_Fptl_Variant8               SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant8                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=8
+#pragma kernel Deferred_Indirect_Fptl_Variant9               SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant9                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=9
+#pragma kernel Deferred_Indirect_Fptl_Variant10              SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant10                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=10
+#pragma kernel Deferred_Indirect_Fptl_Variant11              SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant11                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=11
+#pragma kernel Deferred_Indirect_Fptl_Variant12              SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant12                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=12
+#pragma kernel Deferred_Indirect_Fptl_Variant13              SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant13                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=13
+#pragma kernel Deferred_Indirect_Fptl_Variant14              SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant14                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=14
+#pragma kernel Deferred_Indirect_Fptl_Variant15              SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant15                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=15
+#pragma kernel Deferred_Indirect_Fptl_Variant16              SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant16                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=16
+#pragma kernel Deferred_Indirect_Fptl_Variant17              SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant17                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=17
+#pragma kernel Deferred_Indirect_Fptl_Variant18              SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant18                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=18
+#pragma kernel Deferred_Indirect_Fptl_Variant19              SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant19                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=19
+#pragma kernel Deferred_Indirect_Fptl_Variant20              SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant20                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=20
+#pragma kernel Deferred_Indirect_Fptl_Variant21              SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant21                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=21
+#pragma kernel Deferred_Indirect_Fptl_Variant22              SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant22                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=22
+#pragma kernel Deferred_Indirect_Fptl_Variant23              SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant23                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=23
+#pragma kernel Deferred_Indirect_Fptl_Variant24              SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant24                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=24
+#pragma kernel Deferred_Indirect_Fptl_Variant25              SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant25                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=25
+#pragma kernel Deferred_Indirect_Fptl_Variant26              SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant26                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=26
+#pragma kernel Deferred_Indirect_Fptl_Variant27              SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant27                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=27
+#pragma kernel Deferred_Indirect_Fptl_Variant28              SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant28                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=28
+#pragma kernel Deferred_Indirect_Fptl_Variant29              SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant29                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=29
+#pragma kernel Deferred_Indirect_Fptl_Variant30              SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant30                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=30
+
+/* Tag: SUPPORT_COMPUTE_CLUSTER_OPAQUE - Uncomment this if you want to do cluster opaque with compute shader (by default we support only fptl on opaque)
+#pragma kernel Deferred_Indirect_Clustered_Variant0          SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant0              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=0
+#pragma kernel Deferred_Indirect_Clustered_Variant1          SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant1              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=1
+#pragma kernel Deferred_Indirect_Clustered_Variant2          SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant2              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=2
+#pragma kernel Deferred_Indirect_Clustered_Variant3          SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant3              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=3
+#pragma kernel Deferred_Indirect_Clustered_Variant4          SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant4              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=4
+#pragma kernel Deferred_Indirect_Clustered_Variant5          SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant5              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=5
+#pragma kernel Deferred_Indirect_Clustered_Variant6          SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant6              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=6
+#pragma kernel Deferred_Indirect_Clustered_Variant7          SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant7              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=7
+#pragma kernel Deferred_Indirect_Clustered_Variant8          SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant8              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=8
+#pragma kernel Deferred_Indirect_Clustered_Variant9          SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant9              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=9
+#pragma kernel Deferred_Indirect_Clustered_Variant10         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant10             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=10
+#pragma kernel Deferred_Indirect_Clustered_Variant11         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant11             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=11
+#pragma kernel Deferred_Indirect_Clustered_Variant12         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant12             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=12
+#pragma kernel Deferred_Indirect_Clustered_Variant13         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant13             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=13
+#pragma kernel Deferred_Indirect_Clustered_Variant14         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant14             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=14
+#pragma kernel Deferred_Indirect_Clustered_Variant15         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant15             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=15
+#pragma kernel Deferred_Indirect_Clustered_Variant16         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant16             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=16
+#pragma kernel Deferred_Indirect_Clustered_Variant17         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant17             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=17
+#pragma kernel Deferred_Indirect_Clustered_Variant18         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant18             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=18
+#pragma kernel Deferred_Indirect_Clustered_Variant19         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant19             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=19
+#pragma kernel Deferred_Indirect_Clustered_Variant20         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant20             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=20
+#pragma kernel Deferred_Indirect_Clustered_Variant21         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant21             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=21
+#pragma kernel Deferred_Indirect_Clustered_Variant22         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant22             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=22
+#pragma kernel Deferred_Indirect_Clustered_Variant23         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant23             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=23
+#pragma kernel Deferred_Indirect_Clustered_Variant24         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant24             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=24
+#pragma kernel Deferred_Indirect_Clustered_Variant25         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant25             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=25
+#pragma kernel Deferred_Indirect_Clustered_Variant26         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant26             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=26
+#pragma kernel Deferred_Indirect_Clustered_Variant27         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant27             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=27
+#pragma kernel Deferred_Indirect_Clustered_Variant28         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant28             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=28
+#pragma kernel Deferred_Indirect_Clustered_Variant29         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant29             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=29
+#pragma kernel Deferred_Indirect_Clustered_Variant30         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant30             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=30
+*/
+
+#define LIGHTLOOP_TILE_PASS 1
+
+//#pragma enable_d3d11_debug_symbols
+
+//-------------------------------------------------------------------------------------
+// Include
+//-------------------------------------------------------------------------------------
+
+#include "../../../ShaderLibrary/Common.hlsl"
+#include "../../Debug/DebugDisplay.hlsl"
+
+// Note: We have fix as guidelines that we have only one deferred material (with control of GBuffer enabled). Mean a users that add a new
+// deferred material must replace the old one here. If in the future we want to support multiple layout (cause a lot of consistency problem),
+// the deferred shader will require to use multicompile.
+#define UNITY_MATERIAL_LIT // Need to be define before including Material.hlsl
+#include "../../ShaderConfig.cs.hlsl"
+#include "../../ShaderVariables.hlsl"
+#include "../../Lighting/Lighting.hlsl" // This include Material.hlsl
+
+//-------------------------------------------------------------------------------------
+// variable declaration
+//-------------------------------------------------------------------------------------
+
+DECLARE_GBUFFER_TEXTURE(_GBufferTexture);
+
+RWTexture2D<float3> diffuseLightingUAV;
+RWTexture2D<float4> specularLightingUAV;
+
+CBUFFER_START(UnityDeferredCompute)
+	uint g_TileListOffset;
+CBUFFER_END
+
+#if USE_INDIRECT
+
+StructuredBuffer<uint> g_TileList;
+// Indirect
+[numthreads(16, 16, 1)]
+void SHADE_OPAQUE_ENTRY(uint2 groupThreadId : SV_GroupThreadID, uint groupId : SV_GroupID)
+{
+    uint tileIndex = g_TileList[g_TileListOffset + groupId];
+    uint2 tileCoord = uint2(tileIndex & 0xFFFF, tileIndex >> 16);
+    uint2 pixelCoord = tileCoord * GetTileSize() + groupThreadId;
+
+    uint featureFlags = TileVariantToFeatureFlags(VARIANT);
+#else
+
+// Direct
+[numthreads(16, 16, 1)]
+void SHADE_OPAQUE_ENTRY(uint2 dispatchThreadId : SV_DispatchThreadID, uint2 groupId : SV_GroupID)
+{
+    uint2 tileCoord = (16 * groupId) / GetTileSize();
+    uint2 pixelCoord = dispatchThreadId;
+	uint featureFlags = 0xFFFFFFFF;
+
+#endif
+
+    // This need to stay in sync with deferred.shader
+
+    PositionInputs posInput = GetPositionInput(pixelCoord.xy, _ScreenSize.zw, tileCoord);
+
+    float depth = LOAD_TEXTURE2D(_MainDepthTexture, posInput.unPositionSS).x;
+
+    // For indirect case: we can still overlap inside a tile with the sky/background, reject it
+    // Can't rely on stencil as we are in compute shader
+    // TODO : if we have depth bounds test we could remove such a test ?
+    if (depth == UNITY_RAW_FAR_CLIP_VALUE)
+    {
+        return;
+    }
+
+    UpdatePositionInput(depth, _InvViewProjMatrix, _ViewProjMatrix, posInput);
+    float3 V = GetWorldSpaceNormalizeViewDir(posInput.positionWS);
+
+    FETCH_GBUFFER(gbuffer, _GBufferTexture, posInput.unPositionSS);
+    BSDFData bsdfData;
+    float3 bakeDiffuseLighting;
+    DECODE_FROM_GBUFFER(gbuffer, featureFlags, bsdfData, bakeDiffuseLighting);
+
+    PreLightData preLightData = GetPreLightData(V, posInput, bsdfData);
+
+    float3 diffuseLighting;
+    float3 specularLighting;
+    LightLoop(V, posInput, preLightData, bsdfData, bakeDiffuseLighting, featureFlags, diffuseLighting, specularLighting);
+
+    if (_EnableSSSAndTransmission != 0 && bsdfData.materialId == MATERIALID_LIT_SSS)
+    {
+        // We SSSSS is enabled with use split lighting.
+        // SSSSS algorithm need to know which pixels contribute to SSS and which doesn't. We could use the stencil for that but it mean that it will increase the cost of SSSSS
+        // A simpler solution is to add a slight contribution here that isn't visible (here we chose fp16 min (which is also fp11 and fp10 min).
+        // The SSSSS algorithm will check if diffuse lighting is black and discard the pixel if it is the case
+        diffuseLighting.r = max(diffuseLighting.r, HFLT_MIN);
+
+        specularLightingUAV[pixelCoord] = float4(specularLighting, 1.0);
+        diffuseLightingUAV[pixelCoord]  = diffuseLighting;
+    }
+    else
+    {
+        specularLightingUAV[pixelCoord] = float4(diffuseLighting + specularLighting, 1.0);
+    }
+}
+

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

+// ===================== Performs integration of the Disney BSSRDF over a disk =====================
+
+//--------------------------------------------------------------------------------------------------
+// Definitions
+//--------------------------------------------------------------------------------------------------
+
+// #pragma enable_d3d11_debug_symbols
+
+// Tweak parameters.
+#define SSS_BILATERAL_FILTER  1
+#define SSS_USE_LDS_CACHE     1
+#define SSS_ENABLE_NEAR_FIELD 0
+#define SSS_SAMPLE_TEST_HTILE 0
+#define SSS_USE_TANGENT_PLANE 0
+#define SSS_CLAMP_ARTIFACT    0
+#define SSS_DEBUG_LOD         0
+#define SSS_DEBUG_NORMAL_VS   0
+
+// Do not modify these.
+#define SSS_PASS              1
+#define MILLIMETERS_PER_METER 1000
+#define CENTIMETERS_PER_METER 100
+#define GROUP_SIZE_1D         16
+#define GROUP_SIZE_2D         (GROUP_SIZE_1D * GROUP_SIZE_1D)
+#define TEXTURE_CACHE_BORDER  2
+#define TEXTURE_CACHE_SIZE_1D (GROUP_SIZE_1D + 2 * TEXTURE_CACHE_BORDER)
+
+//--------------------------------------------------------------------------------------------------
+// Included headers
+//--------------------------------------------------------------------------------------------------
+
+#include "../../../../ShaderLibrary/Packing.hlsl"
+#include "../../../../ShaderLibrary/SpaceFillingCurves.hlsl"
+#include "../../../ShaderVariables.hlsl"
+#define UNITY_MATERIAL_LIT
+#include "../../../Material/Material.hlsl"
+#include "../../../Lighting/LightDefinition.cs.hlsl"
+
+//--------------------------------------------------------------------------------------------------
+// Inputs & outputs
+//--------------------------------------------------------------------------------------------------
+
+float4 _WorldScales[SSS_N_PROFILES];                             // Size of the world unit in meters (only the X component is used)
+float4 _FilterKernels[SSS_N_PROFILES][SSS_N_SAMPLES_NEAR_FIELD]; // XY = near field, ZW = far field; 0 = radius, 1 = reciprocal of the PDF
+
+DECLARE_GBUFFER_TEXTURE(_GBufferTexture); // Contains the albedo and SSS parameters
+TEXTURE2D(_DepthTexture);                 // Z-buffer
+TEXTURE2D(_StencilTexture);               // DXGI_FORMAT_R8_UINT is not supported by Unity
+TEXTURE2D(_HTile);                        // DXGI_FORMAT_R8_UINT is not supported by Unity
+TEXTURE2D(_IrradianceSource);             // Includes transmitted light
+
+// Contains the HDR color for non-SSS materials.
+// In case of SSS, it only contains the specular lighting, which we additively blend with the SSS lighting.
+RW_TEXTURE2D(float4, _CameraColorTexture);
+
+//--------------------------------------------------------------------------------------------------
+// Implementation
+//--------------------------------------------------------------------------------------------------
+
+// 6656 bytes used. It appears that the reserved LDS space must be a multiple of 512 bytes.
+#if SSS_USE_LDS_CACHE
+groupshared float4 textureCache[TEXTURE_CACHE_SIZE_1D * TEXTURE_CACHE_SIZE_1D]; // {irradiance, linearDepth}
+#endif
+groupshared bool   processGroup;
+
+bool StencilTest(int2 pixelCoord, float stencilRef)
+{
+    bool passedStencilTest;
+
+#if SSS_SAMPLE_TEST_HTILE
+    int2 tileCoord = pixelCoord >> 3; // Divide by 8
+
+    // Perform the stencil test (reject at the tile rate).
+    passedStencilTest = stencilRef == LOAD_TEXTURE2D(_HTile, tileCoord).r;
+
+    [branch] if (passedStencilTest)
+#else
+    // It is extremely uncommon for individual samples to fail the HTile test.
+    // Unfortunately, our copy of HTile does not allow to accept at the tile rate.
+    // Therefore, we choose not to perform the HiS test here.
+#endif
+    {
+        // Unfortunately, our copy of HTile does not allow to accept at the tile rate.
+        // Therefore, we have to additionally perform the stencil test at the pixel rate.
+        passedStencilTest = stencilRef == UnpackByte(LOAD_TEXTURE2D(_StencilTexture, pixelCoord).r);
+    }
+
+    return passedStencilTest;
+}
+
+#if SSS_USE_LDS_CACHE
+float4 LoadSampleFromCacheMemory(int2 cacheCoord)
+{
+    return textureCache[Mad24(TEXTURE_CACHE_SIZE_1D, cacheCoord.y, cacheCoord.x)];
+}
+#endif
+
+float4 LoadSampleFromVideoMemory(int2 pixelCoord)
+{
+    float3 irradiance = LOAD_TEXTURE2D(_IrradianceSource, pixelCoord).rgb;
+    float  depth      = LOAD_TEXTURE2D(_DepthTexture,     pixelCoord).r;
+
+    return float4(irradiance, LinearEyeDepth(depth, _ZBufferParams));
+}
+
+// Returns {irradiance, linearDepth}.
+float4 LoadSample(int2 pixelCoord, int2 cacheAnchor)
+{
+    int2 cacheCoord = pixelCoord - cacheAnchor;
+    bool isInCache  = max((uint)cacheCoord.x, (uint)cacheCoord.y) < TEXTURE_CACHE_SIZE_1D;
+
+#if SSS_USE_LDS_CACHE
+    [branch] if (isInCache)
+    {
+        return LoadSampleFromCacheMemory(cacheCoord);
+    }
+    else
+#endif
+    {
+        float stencilRef = STENCILLIGHTINGUSAGE_SPLIT_LIGHTING;
+
+        [branch] if (StencilTest(pixelCoord, stencilRef))
+        {
+            return LoadSampleFromVideoMemory(pixelCoord);
+        }
+        else
+        {
+            return float4(0, 0, 0, 0);
+        }
+    }
+}
+
+// Computes the value of the integrand over a disk: (2 * PI * r) * KernelVal().
+// N.b.: the returned value is multiplied by 4. It is irrelevant due to weight renormalization.
+float3 KernelValCircle(float r, float3 S)
+{
+    float3 expOneThird = exp(((-1.0 / 3.0) * r) * S);
+    return /* 0.25 * */ S * (expOneThird + expOneThird * expOneThird * expOneThird);
+}
+
+// Computes F(r)/P(r), s.t. r = sqrt(xy^2 + z^2).
+// Rescaling of the PDF is handled by 'totalWeight'.
+float3 ComputeBilateralWeight(float xy2, float z, float mmPerUnit, float3 S, float rcpPdf)
+{
+#if (SSS_BILATERAL_FILTER == 0)
+    z = 0;
+#endif
+
+#if SSS_USE_TANGENT_PLANE
+    // Both 'xy2' and 'z' require conversion to millimeters.
+    float r = sqrt(xy2 + z * z) * mmPerUnit;
+#else
+    // Only 'z' requires conversion to millimeters.
+    float r = sqrt(xy2 + (z * mmPerUnit) * (z * mmPerUnit));
+#endif
+
+#if SSS_CLAMP_ARTIFACT
+    return saturate(KernelValCircle(r, S) * rcpPdf);
+#else
+    return KernelValCircle(r, S) * rcpPdf;
+#endif
+}
+
+void EvaluateSample(uint i, uint n, uint profileID, uint iR, uint iP, float2 centerCoord, int2 cacheAnchor,
+                    float3 shapeParam, float3 centerPosVS, float mmPerUnit, float2 pixelsPerMm,
+                    float3 tangentX, float3 tangentY, float4x4 projMatrix,
+                    inout float3 totalIrradiance, inout float3 totalWeight)
+{
+    float  r   = _FilterKernels[profileID][i][iR];
+    // The relative sample position is known at the compile time.
+    float  phi = SampleDiskFibonacci(i, n).y;
+    float2 vec = r * float2(cos(phi), sin(phi));
+
+    // Compute the screen-space position and the squared distance (in mm) in the image plane.
+    int2 position; float xy2;
+
+    #if SSS_USE_TANGENT_PLANE
+        float3 relPosVS   = vec.x * tangentX + vec.y * tangentY;
+        float3 positionVS = centerPosVS + relPosVS;
+        float4 positionCS = mul(projMatrix, float4(positionVS, 1));
+        float2 positionSS = ComputeScreenSpacePosition(positionCS);
+
+        position = (int2)(positionSS * _ScreenSize.xy);
+        xy2      = dot(relPosVS.xy, relPosVS.xy);
+    #else
+        position = (int2)(centerCoord + vec * pixelsPerMm);
+        xy2      = r * r;
+    #endif
+
+    float4 textureSample = LoadSample(position, cacheAnchor);
+    float3 irradiance    = textureSample.rgb;
+    float  linearDepth   = textureSample.a;
+
+    // Check the results of the stencil test.
+    if (linearDepth > 0)
+    {
+        // Apply bilateral weighting.
+        float  z = linearDepth - centerPosVS.z;
+        float  p = _FilterKernels[profileID][i][iP];
+        float3 w = ComputeBilateralWeight(xy2, z, mmPerUnit, shapeParam, p);
+
+        totalIrradiance += w * irradiance;
+        totalWeight     += w;
+    }
+}
+
+#pragma kernel SubsurfaceScattering
+
+[numthreads(GROUP_SIZE_2D, 1, 1)]
+void SubsurfaceScattering(uint2 groupId       : SV_GroupID,
+                          uint  groupThreadId : SV_GroupThreadID)
+{
+    // Note: any factor of 64 is a suitable wave size for our algorithm.
+    uint waveIndex = groupThreadId / 64;
+    uint laneIndex = groupThreadId % 64;
+    uint quadIndex = laneIndex / 4;
+
+    // Arrange threads in the Morton order to optimally match the memory layout of GCN tiles.
+    uint  mortonCode  = groupThreadId;
+    uint2 localCoord  = DecodeMorton2D(mortonCode);
+    uint2 tileAnchor  = groupId * GROUP_SIZE_1D;
+    uint2 pixelCoord  = tileAnchor + localCoord;
+    int2  cacheAnchor = (int2)tileAnchor - TEXTURE_CACHE_BORDER;
+    uint2 cacheCoord  = localCoord + TEXTURE_CACHE_BORDER;
+    float stencilRef  = STENCILLIGHTINGUSAGE_SPLIT_LIGHTING;
+
+    [branch] if (groupThreadId == 0)
+    {
+        // 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;
+
+        // Perform the stencil test (reject at the tile rate).
+        processGroup = (stencilRef == s00 || stencilRef == s10 || stencilRef == s01 || stencilRef == s11);
+    }
+
+    // Wait for the LDS.
+    GroupMemoryBarrierWithGroupSync();
+
+    [branch] if (!processGroup) { return; }
+
+    float3 centerIrradiance = 0;
+    float  centerDepth      = 0;
+    float4 cachedValue      = float4(0, 0, 0, 0);
+
+    bool passedStencilTest = StencilTest((int2)pixelCoord, stencilRef);
+
+    [branch] if (passedStencilTest)
+    {
+        centerIrradiance = LOAD_TEXTURE2D(_IrradianceSource, pixelCoord).rgb;
+        centerDepth      = LOAD_TEXTURE2D(_DepthTexture,     pixelCoord).r;
+        cachedValue      = float4(centerIrradiance, LinearEyeDepth(centerDepth, _ZBufferParams));
+    }
+
+#if SSS_USE_LDS_CACHE
+    // Populate the central region of the LDS cache.
+    textureCache[Mad24(TEXTURE_CACHE_SIZE_1D, cacheCoord.y, cacheCoord.x)] = cachedValue;
+
+    uint numBorderQuadsPerWave = TEXTURE_CACHE_SIZE_1D / 2 - 1;
+    uint halfCacheWidthInQuads = TEXTURE_CACHE_SIZE_1D / 4;
+
+    [branch] if (quadIndex < numBorderQuadsPerWave)
+    {
+        // Fetch another texel into the LDS.
+        uint2 startQuad = halfCacheWidthInQuads * uint2(waveIndex & 1, waveIndex >> 1);
+
+        uint2 quadCoord;
+
+        // The traversal order is such that the quad's X coordinate is monotonically increasing.
+        // Note: the compiler can heavily optimize the code below, as the switch is scalar,
+        // and there are very few unique values due to the symmetry.
+        switch (waveIndex)
+        {
+            case 0:
+                quadCoord.x = max(0, (int)(quadIndex - (halfCacheWidthInQuads - 1)));
+                quadCoord.y = max(0, (int)((halfCacheWidthInQuads - 1) - quadIndex));
+                break;
+            case 1:
+                quadCoord.x = min(quadIndex, halfCacheWidthInQuads - 1);
+                quadCoord.y = max(0, (int)(quadIndex - (halfCacheWidthInQuads - 1)));
+                break;
+            case 2:
+                quadCoord.x = max(0, (int)(quadIndex - (halfCacheWidthInQuads - 1)));
+                quadCoord.y = min(quadIndex, halfCacheWidthInQuads - 1);
+                break;
+            default: // 3
+                quadCoord.x = min(quadIndex, halfCacheWidthInQuads - 1);
+                quadCoord.y = min(halfCacheWidthInQuads - 1, 2 * (halfCacheWidthInQuads - 1) - quadIndex);
+                break;
+        }
+
+        uint2  cacheCoord2  = 2 * (startQuad + quadCoord) + uint2(laneIndex & 1, (laneIndex >> 1) & 1);
+        int2   pixelCoord2  = (int2)(tileAnchor + cacheCoord2) - TEXTURE_CACHE_BORDER;
+        float4 cachedValue2 = float4(0, 0, 0, 0);
+
+        [branch] if (StencilTest(pixelCoord2, stencilRef))
+        {
+            cachedValue2 = LoadSampleFromVideoMemory(pixelCoord2);
+        }
+
+        // Populate the border region of the LDS cache.
+        textureCache[Mad24(TEXTURE_CACHE_SIZE_1D, cacheCoord2.y, cacheCoord2.x)] = cachedValue2;
+    }
+
+    // Wait for the LDS.
+    GroupMemoryBarrierWithGroupSync();
+#endif
+
+    bool isOffScreen = pixelCoord.x >= (uint)_ScreenSize.x || pixelCoord.y >= (uint)_ScreenSize.y;
+
+    [branch] if (!passedStencilTest || isOffScreen) { return; }
+
+    PositionInputs posInput = GetPositionInput(pixelCoord, _ScreenSize.zw);
+
+    float3 unused;
+
+    // The result of the stencil test allows us to statically determine the material type (SSS).
+    BSDFData bsdfData;
+    FETCH_GBUFFER(gbuffer, _GBufferTexture, pixelCoord);
+    DECODE_FROM_GBUFFER(gbuffer, MATERIALFEATUREFLAGS_LIT_SSS, bsdfData, unused);
+
+    int    profileID   = bsdfData.subsurfaceProfile;
+    float  distScale   = bsdfData.subsurfaceRadius;
+    float3 shapeParam  = _ShapeParams[profileID].rgb;
+    float  maxDistance = _ShapeParams[profileID].a;
+
+    // Reconstruct the view-space position corresponding to the central sample.
+    float2 centerPosSS = posInput.positionSS;
+    float2 cornerPosSS = centerPosSS + 0.5 * _ScreenSize.zw;
+    float3 centerPosVS = ComputeViewSpacePosition(centerPosSS, centerDepth, _InvProjMatrix);
+    float3 cornerPosVS = ComputeViewSpacePosition(cornerPosSS, centerDepth, _InvProjMatrix);
+
+    // Rescaling the filter is equivalent to inversely scaling the world.
+    float mmPerUnit  = MILLIMETERS_PER_METER * (_WorldScales[profileID].x / distScale);
+    float unitsPerMm = rcp(mmPerUnit);
+
+    // Compute the view-space dimensions of the pixel as a quad projected onto geometry.
+    float2 unitsPerPixel = 2 * abs(cornerPosVS.xy - centerPosVS.xy);
+    float2 pixelsPerMm   = rcp(unitsPerPixel) * unitsPerMm;
+
+    // We perform point sampling. Therefore, we can avoid the cost
+    // of filtering if we stay within the bounds of the current pixel.
+    // We use the value of 1 instead of 0.5 as an optimization.
+    // N.b.: our LoD selection algorithm is the same regardless of
+    // whether we integrate over the tangent plane or not, since we
+    // don't want the orientation of the tangent plane to create
+    // divergence of execution across the warp.
+    float maxDistInPixels = maxDistance * max(pixelsPerMm.x, pixelsPerMm.y);
+
+    [branch] if (distScale == 0 || maxDistInPixels < 1)
+    {
+        #if SSS_DEBUG_LOD
+            _CameraColorTexture[pixelCoord] = float4(0, 0, 1, 1);
+        #else
+            _CameraColorTexture[pixelCoord] += float4(bsdfData.diffuseColor * centerIrradiance, 1);
+        #endif
+            return;
+    }
+
+    float4x4 viewMatrix, projMatrix;
+    GetLeftHandedViewSpaceMatrices(viewMatrix, projMatrix);
+
+    // Compute the tangent frame in view space.
+    float3 normalVS = mul((float3x3)viewMatrix, bsdfData.normalWS);
+    float3 tangentX = GetLocalFrame(normalVS)[0] * unitsPerMm;
+    float3 tangentY = GetLocalFrame(normalVS)[1] * unitsPerMm;
+
+#if SSS_DEBUG_NORMAL_VS
+    // We expect the view-space normal to be front-facing.
+    if (normalVS.z >= 0)
+    {
+        _CameraColorTexture[pixelCoord] = float4(1, 1, 1, 1);
+        return;
+    }
+#endif
+
+    // Use more samples for SS regions larger than 5x5 pixels (rotated by 45 degrees).
+    bool useNearFieldKernel = SSS_ENABLE_NEAR_FIELD && maxDistInPixels > SSS_LOD_THRESHOLD;
+
+#if SSS_DEBUG_LOD
+    _CameraColorTexture[pixelCoord] = useNearFieldKernel ? float4(1, 0, 0, 1) : float4(0.5, 0.5, 0, 1);
+    return;
+#endif
+
+    // Compute the indices used to access the individual components of the float4 of the kernel.
+    uint iR = useNearFieldKernel ? 0 : 2; // radius
+    uint iP = useNearFieldKernel ? 1 : 3; // rcp(pdf)
+
+    float  centerRadius = _FilterKernels[profileID][0][iR];
+    float  centerRcpPdf = _FilterKernels[profileID][0][iP];
+    float3 centerWeight = KernelValCircle(centerRadius, shapeParam) * centerRcpPdf;
+
+    // Accumulate filtered irradiance and bilateral weights (for renormalization).
+    float3 totalIrradiance = centerWeight * centerIrradiance;
+    float3 totalWeight     = centerWeight;
+
+    int i, n; // Declare once to avoid the warning from the Unity shader compiler.
+
+    [unroll]
+    for (i = 1, n = SSS_N_SAMPLES_FAR_FIELD; i < n; i++)
+    {
+        // Integrate over the image or tangent plane in the view space.
+        EvaluateSample(i, n, profileID, iR, iP, pixelCoord + 0.5, cacheAnchor,
+                       shapeParam, centerPosVS, mmPerUnit, pixelsPerMm,
+                       tangentX, tangentY, projMatrix,
+                       totalIrradiance, totalWeight);
+    }
+
+    [branch] if (!useNearFieldKernel)
+    {
+         _CameraColorTexture[pixelCoord] += float4(bsdfData.diffuseColor * totalIrradiance / totalWeight, 1);
+         return;
+    }
+
+    [unroll]
+    for (i = SSS_N_SAMPLES_FAR_FIELD, n = SSS_N_SAMPLES_NEAR_FIELD; i < n; i++)
+    {
+        // Integrate over the image or tangent plane in the view space.
+        EvaluateSample(i, n, profileID, iR, iP, pixelCoord + 0.5, cacheAnchor,
+                       shapeParam, centerPosVS, mmPerUnit, pixelsPerMm,
+                       tangentX, tangentY, projMatrix,
+                       totalIrradiance, totalWeight);
+    }
+
+    _CameraColorTexture[pixelCoord] += float4(bsdfData.diffuseColor * totalIrradiance / totalWeight, 1);
+}

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

+fileFormatVersion: 2
+guid: b06a7993621def248addd55d0fe931b1
+timeCreated: 1500310187
+licenseType: Pro
+ComputeShaderImporter:
+  externalObjects: {}
+  currentAPIMask: 4
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderPipeline/ShaderLibrary/Noise.hlsl

+#ifndef UNITY_NOISE_INCLUDED
+#define UNITY_NOISE_INCLUDED
+
+// A single iteration of Bob Jenkins' One-At-A-Time hashing algorithm.
+uint JenkinsHash(uint x)
+{
+    x += (x << 10u);
+    x ^= (x >>  6u);
+    x += (x <<  3u);
+    x ^= (x >> 11u);
+    x += (x << 15u);
+    return x;
+}
+
+// Compound versions of the hashing algorithm.
+uint JenkinsHash(uint2 v)
+{
+    return JenkinsHash(v.x ^ JenkinsHash(v.y));
+}
+
+uint JenkinsHash(uint3 v)
+{
+    return JenkinsHash(v.x ^ JenkinsHash(v.y) ^ JenkinsHash(v.z));
+}
+
+uint JenkinsHash(uint4 v)
+{
+    return JenkinsHash(v.x ^ JenkinsHash(v.y) ^ JenkinsHash(v.z) ^ JenkinsHash(v.w));
+}
+
+// Construct a float with half-open range [0:1] using low 23 bits.
+// All zeros yields 0, all ones yields the next smallest representable value below 1.
+float ConstructFloat(uint m) {
+    const uint ieeeMantissa = 0x007FFFFFu; // Binary FP32 mantissa bitmask
+    const uint ieeeOne      = 0x3F800000u; // 1.0 in FP32 IEEE
+
+    m &= ieeeMantissa;                     // Keep only mantissa bits (fractional part)
+    m |= ieeeOne;                          // Add fractional part to 1.0
+
+    float  f = asfloat(m);                 // Range [1:2]
+    return f - 1;                          // Range [0:1]
+}
+
+// Pseudo-random value in half-open range [0:1]. The distribution is reasonably uniform.
+// Ref: https://stackoverflow.com/a/17479300
+float GenerateHashedRandomFloat(uint x)
+{
+    return ConstructFloat(JenkinsHash(x));
+}
+
+float GenerateHashedRandomFloat(uint2 v)
+{
+    return ConstructFloat(JenkinsHash(v));
+}
+
+float GenerateHashedRandomFloat(uint3 v)
+{
+    return ConstructFloat(JenkinsHash(v));
+}
+
+float GenerateHashedRandomFloat(uint4 v)
+{
+    return ConstructFloat(JenkinsHash(v));
+}
+
+#endif // UNITY_NOISE_INCLUDED

Assets/ScriptableRenderPipeline/ShaderLibrary/Noise.hlsl.meta

+fileFormatVersion: 2
+guid: 5918bc8b07f593546974c1961387db77
+timeCreated: 1501167559
+licenseType: Pro
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderPipeline/ShaderLibrary/SpaceFillingCurves.hlsl

+#ifndef UNITY_SPACE_FILLING_CURVES_INCLUDED
+#define UNITY_SPACE_FILLING_CURVES_INCLUDED
+
+// "Insert" a 0 bit after each of the 16 low bits of x.
+// Ref: https://fgiesen.wordpress.com/2009/12/13/decoding-morton-codes/
+uint Part1By1(uint x)
+{
+  x &= 0x0000ffff;                  // x = ---- ---- ---- ---- fedc ba98 7654 3210
+  x = (x ^ (x <<  8)) & 0x00ff00ff; // x = ---- ---- fedc ba98 ---- ---- 7654 3210
+  x = (x ^ (x <<  4)) & 0x0f0f0f0f; // x = ---- fedc ---- ba98 ---- 7654 ---- 3210
+  x = (x ^ (x <<  2)) & 0x33333333; // x = --fe --dc --ba --98 --76 --54 --32 --10
+  x = (x ^ (x <<  1)) & 0x55555555; // x = -f-e -d-c -b-a -9-8 -7-6 -5-4 -3-2 -1-0
+  return x;
+}
+
+// "Insert" two 0 bits after each of the 10 low bits of x/
+// Ref: https://fgiesen.wordpress.com/2009/12/13/decoding-morton-codes/
+uint Part1By2(uint x)
+{
+  x &= 0x000003ff;                  // x = ---- ---- ---- ---- ---- --98 7654 3210
+  x = (x ^ (x << 16)) & 0xff0000ff; // x = ---- --98 ---- ---- ---- ---- 7654 3210
+  x = (x ^ (x <<  8)) & 0x0300f00f; // x = ---- --98 ---- ---- 7654 ---- ---- 3210
+  x = (x ^ (x <<  4)) & 0x030c30c3; // x = ---- --98 ---- 76-- --54 ---- 32-- --10
+  x = (x ^ (x <<  2)) & 0x09249249; // x = ---- 9--8 --7- -6-- 5--4 --3- -2-- 1--0
+  return x;
+}
+
+// Inverse of Part1By1 - "delete" all odd-indexed bits/
+// Ref: https://fgiesen.wordpress.com/2009/12/13/decoding-morton-codes/
+uint Compact1By1(uint x)
+{
+  x &= 0x55555555;                  // x = -f-e -d-c -b-a -9-8 -7-6 -5-4 -3-2 -1-0
+  x = (x ^ (x >>  1)) & 0x33333333; // x = --fe --dc --ba --98 --76 --54 --32 --10
+  x = (x ^ (x >>  2)) & 0x0f0f0f0f; // x = ---- fedc ---- ba98 ---- 7654 ---- 3210
+  x = (x ^ (x >>  4)) & 0x00ff00ff; // x = ---- ---- fedc ba98 ---- ---- 7654 3210
+  x = (x ^ (x >>  8)) & 0x0000ffff; // x = ---- ---- ---- ---- fedc ba98 7654 3210
+  return x;
+}
+
+// Inverse of Part1By2 - "delete" all bits not at positions divisible by 3/
+// Ref: https://fgiesen.wordpress.com/2009/12/13/decoding-morton-codes/
+uint Compact1By2(uint x)
+{
+  x &= 0x09249249;                  // x = ---- 9--8 --7- -6-- 5--4 --3- -2-- 1--0
+  x = (x ^ (x >>  2)) & 0x030c30c3; // x = ---- --98 ---- 76-- --54 ---- 32-- --10
+  x = (x ^ (x >>  4)) & 0x0300f00f; // x = ---- --98 ---- ---- 7654 ---- ---- 3210
+  x = (x ^ (x >>  8)) & 0xff0000ff; // x = ---- --98 ---- ---- ---- ---- 7654 3210
+  x = (x ^ (x >> 16)) & 0x000003ff; // x = ---- ---- ---- ---- ---- --98 7654 3210
+  return x;
+}
+
+uint EncodeMorton2D(uint2 coord)
+{
+	return (Part1By1(coord.y) << 1) + Part1By1(coord.x);
+}
+
+uint EncodeMorton3D(uint3 coord)
+{
+	return (Part1By2(coord.z) << 2) + (Part1By2(coord.y) << 1) + Part1By2(coord.x);
+}
+
+uint2 DecodeMorton2D(uint code)
+{
+	return uint2(Compact1By1(code >> 0), Compact1By1(code >> 1));
+}
+
+uint3 DecodeMorton3D(uint code)
+{
+	return uint3(Compact1By2(code >> 0), Compact1By2(code >> 1), Compact1By2(code >> 2));
+}
+
+#endif // UNITY_SPACE_FILLING_CURVES_INCLUDED

Assets/ScriptableRenderPipeline/ShaderLibrary/SpaceFillingCurves.hlsl.meta

+fileFormatVersion: 2
+guid: 063144fddd2c1be41b9d09dec6314fc7
+timeCreated: 1500391830
+licenseType: Pro
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/GraphicTest/SSS/ProfilingSkinSSSProfile.asset

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: a6e7465350bf0d248b4799d98e18cd24, type: 3}
+  m_Name: ProfilingSkinSSSProfile
+  m_EditorClassIdentifier: 
+  scatteringDistance: {r: 0.758, g: 0.321, b: 0.201, a: 1}
+  transmissionTint: {r: 0.7568628, g: 0.32156864, b: 0.20000002, a: 1}
+  texturingMode: 0
+  transmissionMode: 0
+  thicknessRemap: {x: 0, y: 12.031147}
+  worldScale: 1
+  settingsIndex: 4
+  m_ShapeParam: {x: 1.3192612, y: 3.1152647, z: 4.9751244}
+  m_MaxRadius: 10.03481
+  m_FilterKernelNearField:
+  - {x: 0.013865918, y: 1.5345725}
+  - {x: 0.04211352, y: 1.5729346}
+  - {x: 0.07107388, y: 1.6130018}
+  - {x: 0.100779116, y: 1.6548817}
+  - {x: 0.13126306, y: 1.6986896}
+  - {x: 0.16256203, y: 1.7445502}
+  - {x: 0.1947145, y: 1.7925992}
+  - {x: 0.22776169, y: 1.8429838}
+  - {x: 0.26174724, y: 1.8958628}
+  - {x: 0.29671827, y: 1.9514104}
+  - {x: 0.33272493, y: 2.0098157}
+  - {x: 0.369821, y: 2.0712852}
+  - {x: 0.40806437, y: 2.1360447}
+  - {x: 0.44751683, y: 2.2043417}
+  - {x: 0.48824534, y: 2.276447}
+  - {x: 0.5303216, y: 2.3526597}
+  - {x: 0.5738235, y: 2.433308}
+  - {x: 0.61883456, y: 2.5187542}
+  - {x: 0.665446, y: 2.609401}
+  - {x: 0.713756, y: 2.7056925}
+  - {x: 0.763872, y: 2.808125}
+  - {x: 0.8159103, y: 2.91725}
+  - {x: 0.8699981, y: 3.0336854}
+  - {x: 0.9262747, y: 3.1581244}
+  - {x: 0.98489225, y: 3.2913465}
+  - {x: 1.0460185, y: 3.434234}
+  - {x: 1.1098381, y: 3.5877857}
+  - {x: 1.1765549, y: 3.7531407}
+  - {x: 1.2463952, y: 3.9316032}
+  - {x: 1.319611, y: 4.124672}
+  - {x: 1.3964823, y: 4.3340797}
+  - {x: 1.4773248, y: 4.561845}
+  - {x: 1.5624928, y: 4.810328}
+  - {x: 1.6523882, y: 5.082317}
+  - {x: 1.747467, y: 5.381122}
+  - {x: 1.8482518, y: 5.710715}
+  - {x: 1.9553448, y: 6.0759025}
+  - {x: 2.069445, y: 6.482568}
+  - {x: 2.1913698, y: 6.9379897}
+  - {x: 2.3220856, y: 7.4513016}
+  - {x: 2.4627466, y: 8.0341215}
+  - {x: 2.614747, y: 8.701484}
+  - {x: 2.7797952, y: 9.473195}
+  - {x: 2.9600194, y: 10.375936}
+  - {x: 3.1581159, y: 11.446505}
+  - {x: 3.3775842, y: 12.737201}
+  - {x: 3.6230793, y: 14.324919}
+  - {x: 3.9009922, y: 16.327562}
+  - {x: 4.220452, y: 18.935623}
+  - {x: 4.5951686, y: 22.478209}
+  - {x: 5.047148, y: 27.57712}
+  - {x: 5.615129, y: 35.564823}
+  - {x: 6.3776174, y: 49.90625}
+  - {x: 7.5374603, y: 83.30668}
+  - {x: 10.03481, y: 250.11497}
+  m_FilterKernelFarField:
+  - {x: 0.03667902, y: 1.5654991}
+  - {x: 0.11374626, y: 1.6734134}
+  - {x: 0.19626758, y: 1.7949444}
+  - {x: 0.28494877, y: 1.9325867}
+  - {x: 0.38062802, y: 2.0894418}
+  - {x: 0.48430943, y: 2.2694077}
+  - {x: 0.59720695, y: 2.4774427}
+  - {x: 0.72080237, y: 2.7199378}
+  - {x: 0.8569269, y: 3.005264}
+  - {x: 1.007873, y: 3.3445888}
+  - {x: 1.1765549, y: 3.7531407}
+  - {x: 1.3667475, y: 4.252257}
+  - {x: 1.5834517, y: 4.872841}
+  - {x: 1.8334827, y: 5.6615734}
+  - {x: 2.126473, y: 6.692844}
+  - {x: 2.4767098, y: 8.093767}
+  - {x: 2.9068332, y: 10.102725}
+  - {x: 3.4562516, y: 13.228675}
+  - {x: 4.2041187, y: 18.793621}
+  - {x: 5.3538504, y: 31.646347}
+  - {x: 7.84603, y: 95.44374}
+  scatterDistance1: {r: 0.3, g: 0.2, b: 0.2, a: 0}
+  scatterDistance2: {r: 0.6, g: 0.2, b: 0.2, a: 0}
+  lerpWeight: 0.5
+  m_HalfRcpWeightedVariances: {x: 2.4691355, y: 12.5, z: 12.5, w: 2.4691355}
+  m_FilterKernelBasic:
+  - {x: 0.09090909, y: 0.21162307, z: 0.21162307, w: -0.000000048879357}
+  - {x: 0.09090909, y: 0.18990478, z: 0.18990478, w: -0.11381993}
+  - {x: 0.09090909, y: 0.13233659, z: 0.13233659, w: -0.23580086}
+  - {x: 0.09090909, y: 0.061445467, z: 0.061445467, w: -0.37865555}
+  - {x: 0.09090909, y: 0.010501689, z: 0.010501689, w: -0.57677805}
+  - {x: 0.09090909, y: 2.9458339e-10, z: 2.9458339e-10, w: -1.3907351}
+  - {x: 0.09090909, y: 0.18990476, z: 0.18990476, w: 0.11382001}
+  - {x: 0.09090909, y: 0.13233659, z: 0.13233659, w: 0.23580086}
+  - {x: 0.09090909, y: 0.061445467, z: 0.061445467, w: 0.37865555}
+  - {x: 0.09090909, y: 0.010501689, z: 0.010501689, w: 0.57677805}
+  - {x: 0.09090909, y: 2.9456845e-10, z: 2.9456845e-10, w: 1.3907368}

Assets/TestScenes/HDTest/GraphicTest/SSS/ProfilingSkinSSSProfile.asset.meta

+fileFormatVersion: 2
+guid: aa5f2cc1c22cad043a617e9e9548b1b9
+timeCreated: 1493291209
+licenseType: Pro
+NativeFormatImporter:
+  mainObjectFileID: 11400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/GraphicTest/SSS/Test - SSS model .prefab.meta

+fileFormatVersion: 2
+guid: ef1a9eb2ee53a8f44bf5543cfe520dc7
+timeCreated: 1500646713
+licenseType: Pro
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 100100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/SSSProfiling.unity.meta

+fileFormatVersion: 2
+guid: 3ae49a004ada4ea4486096f6ed8c5d46
+timeCreated: 1500647185
+licenseType: Pro
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/shadeopaque.compute

-#pragma kernel ShadeOpaque_Direct_Fptl                          SHADE_OPAQUE_ENTRY=ShadeOpaque_Direct_Fptl                              USE_FPTL_LIGHTLIST
-#pragma kernel ShadeOpaque_Direct_Fptl_DebugDisplay             SHADE_OPAQUE_ENTRY=ShadeOpaque_Direct_Fptl_DebugDisplay                 USE_FPTL_LIGHTLIST        DEBUG_DISPLAY
-#pragma kernel ShadeOpaque_Direct_Clustered                     SHADE_OPAQUE_ENTRY=ShadeOpaque_Direct_Clustered                         USE_CLUSTERED_LIGHTLIST
-#pragma kernel ShadeOpaque_Direct_Clustered_DebugDisplay        SHADE_OPAQUE_ENTRY=ShadeOpaque_Direct_Clustered_DebugDisplay            USE_CLUSTERED_LIGHTLIST   DEBUG_DISPLAY
-
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant0               SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant0                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=0
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant1               SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant1                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=1
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant2               SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant2                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=2
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant3               SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant3                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=3
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant4               SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant4                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=4
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant5               SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant5                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=5
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant6               SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant6                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=6
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant7               SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant7                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=7
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant8               SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant8                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=8
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant9               SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant9                   USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=9
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant10              SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant10                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=10
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant11              SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant11                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=11
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant12              SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant12                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=12
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant13              SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant13                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=13
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant14              SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant14                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=14
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant15              SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant15                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=15
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant16              SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant16                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=16
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant17              SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant17                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=17
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant18              SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant18                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=18
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant19              SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant19                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=19
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant20              SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant20                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=20
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant21              SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant21                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=21
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant22              SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant22                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=22
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant23              SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant23                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=23
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant24              SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant24                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=24
-#pragma kernel ShadeOpaque_Indirect_Fptl_Variant25              SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Fptl_Variant25                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=25
-
-// TODO: We should remove these variant for cluster opaque and only keep tile opaque.
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant0          SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant0              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=0
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant1          SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant1              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=1
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant2          SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant2              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=2
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant3          SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant3              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=3
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant4          SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant4              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=4
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant5          SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant5              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=5
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant6          SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant6              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=6
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant7          SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant7              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=7
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant8          SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant8              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=8
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant9          SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant9              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=9
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant10         SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant10             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=10
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant11         SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant11             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=11
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant12         SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant12             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=12
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant13         SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant13             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=13
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant14         SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant14             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=14
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant15         SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant15             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=15
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant16         SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant16             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=16
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant17         SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant17             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=17
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant18         SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant18             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=18
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant19         SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant19             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=19
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant20         SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant20             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=20
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant21         SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant21             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=21
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant22         SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant22             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=22
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant23         SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant23             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=23
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant24         SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant24             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=24
-#pragma kernel ShadeOpaque_Indirect_Clustered_Variant25         SHADE_OPAQUE_ENTRY=ShadeOpaque_Indirect_Clustered_Variant25             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=25
-
-
-#define LIGHTLOOP_TILE_PASS 1
-#define LIGHTLOOP_TILE_DIRECT 1
-#define LIGHTLOOP_TILE_INDIRECT 1
-#define LIGHTLOOP_TILE_ALL 1
-
-//#pragma enable_d3d11_debug_symbols
-
-//-------------------------------------------------------------------------------------
-// Include
-//-------------------------------------------------------------------------------------
-
-#include "../../../ShaderLibrary/Common.hlsl"
-#include "../../Debug/DebugDisplay.hlsl"
-
-// Note: We have fix as guidelines that we have only one deferred material (with control of GBuffer enabled). Mean a users that add a new
-// deferred material must replace the old one here. If in the future we want to support multiple layout (cause a lot of consistency problem),
-// the deferred shader will require to use multicompile.
-#define UNITY_MATERIAL_LIT // Need to be define before including Material.hlsl
-#include "../../ShaderConfig.cs.hlsl"
-#include "../../ShaderVariables.hlsl"
-#include "../../Lighting/Lighting.hlsl" // This include Material.hlsl
-
-//-------------------------------------------------------------------------------------
-// variable declaration
-//-------------------------------------------------------------------------------------
-
-DECLARE_GBUFFER_TEXTURE(_GBufferTexture);
-
-RWTexture2D<float3> diffuseLightingUAV;
-RWTexture2D<float4> specularLightingUAV;
-
-CBUFFER_START(UnityShadeOpaque)
-	uint g_TileListOffset;
-CBUFFER_END
-
-#if USE_INDIRECT
-    StructuredBuffer<uint> g_TileList;
-// Indirect
-[numthreads(16, 16, 1)]
-void SHADE_OPAQUE_ENTRY(uint2 groupThreadId : SV_GroupThreadID, uint groupId : SV_GroupID)
-{
-    uint tileIndex = g_TileList[g_TileListOffset + groupId];
-    uint2 tileCoord = uint2(tileIndex & 0xFFFF, tileIndex >> 16);
-    uint2 pixelCoord = tileCoord * GetTileSize() + groupThreadId;
-
-    PositionInputs posInput = GetPositionInput(pixelCoord.xy, _ScreenSize.zw, tileCoord);
-    uint featureFlags = TileVariantToFeatureFlags(VARIANT);
-#else
-// Direct
-[numthreads(16, 16, 1)]
-void SHADE_OPAQUE_ENTRY(uint2 dispatchThreadId : SV_DispatchThreadID, uint2 groupId : SV_GroupID)
-{
-    uint2 pixelCoord = dispatchThreadId;
-    PositionInputs posInput = GetPositionInput(pixelCoord.xy, _ScreenSize.zw, groupId);
-	uint featureFlags = 0xFFFFFFFF;
-#endif
-
-    float depth = LOAD_TEXTURE2D(_MainDepthTexture, posInput.unPositionSS).x;
-
-    // For indirect case: we can still overlap inside a tile with the sky/background, reject it
-    // Can't rely on stencil as we are in compute shader
-    // TODO : if we have depth bounds test we could remove such a test ?
-    if (depth == UNITY_RAW_FAR_CLIP_VALUE)
-    {
-        return;
-    }
-
-    UpdatePositionInput(depth, _InvViewProjMatrix, _ViewProjMatrix, posInput);
-    float3 V = GetWorldSpaceNormalizeViewDir(posInput.positionWS);
-
-    FETCH_GBUFFER(gbuffer, _GBufferTexture, posInput.unPositionSS);
-    BSDFData bsdfData;
-    float3 bakeDiffuseLighting;
-    DECODE_FROM_GBUFFER(gbuffer, featureFlags, bsdfData, bakeDiffuseLighting);
-
-    PreLightData preLightData = GetPreLightData(V, posInput, bsdfData);
-
-    float3 diffuseLighting;
-    float3 specularLighting;
-    LightLoop(V, posInput, preLightData, bsdfData, bakeDiffuseLighting, featureFlags, diffuseLighting, specularLighting);
-
-    if (_EnableSSSAndTransmission != 0 && bsdfData.materialId == MATERIALID_LIT_SSS)
-    {
-        // We SSSSS is enabled with use split lighting.
-        // SSSSS algorithm need to know which pixels contribute to SSS and which doesn't. We could use the stencil for that but it mean that it will increase the cost of SSSSS
-        // A simpler solution is to add a slight contribution here that isn't visible (here we chose fp16 min (which is also fp11 and fp10 min).
-        // The SSSSS algorithm will check if diffuse lighting is black and discard the pixel if it is the case
-        diffuseLighting.r = max(diffuseLighting.r, HFLT_MIN);
-
-        specularLightingUAV[pixelCoord] = float4(specularLighting, 1.0);
-        diffuseLightingUAV[pixelCoord]  = diffuseLighting;
-    }
-    else
-    {
-        specularLightingUAV[pixelCoord] = float4(diffuseLighting + specularLighting, 1.0);
-    }
-}
-

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/SSSProfile/Resources.meta

-fileFormatVersion: 2
-guid: 59a5ca19094a8c64099eded20685322f
-folderAsset: yes
-timeCreated: 1500627638
-licenseType: Pro
-DefaultImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Resources.meta

-fileFormatVersion: 2
-guid: 2b0e7252e10375942943003cdd139be0
-folderAsset: yes
-timeCreated: 1500627615
-licenseType: Pro
-DefaultImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: