Merge branch 'master'

Assets/GraphicsTests/Framework/Editor/TestFramework.cs

                 yield return null;
             }
 
-            while (Lightmapping.isRunning)
+            while (UnityEditor.Lightmapping.isRunning)
             {
                 yield return null;
             }

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/Core/Shadow/Shadow.cs

                 // For lights with multiple faces, the first shadow data contains
                 // per light information, so not all fields contain valid data.
                 // Shader code must make sure to read per face data from per face entries.
-                sd.texelSizeRcp = new Vector2( m_WidthRcp, m_HeightRcp );
+                sd.texelSizeRcp = new Vector4( m_WidthRcp, m_HeightRcp, 1.0f / widths[0], 1.0f / heights[0] );
                 sd.PackShadowType( sr.shadowType, sanitizedAlgo );
                 sd.payloadOffset = payload.Count();
                 entries.AddUnchecked( sd );

Assets/ScriptableRenderPipeline/Core/TextureCache.cs

 
             if (!TextureCache.supportsCubemapArrayTextures)
             {
-                if (!m_CubeBlitMaterial) m_CubeBlitMaterial = new Material(Shader.Find("Hidden/CubeToPano"));
+                if (!m_CubeBlitMaterial) m_CubeBlitMaterial = new Material(Shader.Find("Hidden/CubeToPano")) { hideFlags = HideFlags.HideAndDontSave };
 
                 int panoWidthTop = 4 * width;
                 int panoHeightTop = 2 * width;
                 m_StagingRTs = new RenderTexture[m_NumPanoMipLevels];
                 for (int m = 0; m < m_NumPanoMipLevels; m++)
                 {
-                    m_StagingRTs[m] = new RenderTexture(Mathf.Max(1, panoWidthTop >> m), Mathf.Max(1, panoHeightTop >> m), 0, RenderTextureFormat.ARGBHalf);
+                    m_StagingRTs[m] = new RenderTexture(Mathf.Max(1, panoWidthTop >> m), Mathf.Max(1, panoHeightTop >> m), 0, RenderTextureFormat.ARGBHalf) { hideFlags = HideFlags.HideAndDontSave };
                 }
 
                 if (m_CubeBlitMaterial)
     {
         protected int m_NumMipLevels;
 
-        static int s_GlobalTextureCacheVersion = 0;
-        int m_TextureCacheVersion = 0;
+#if UNITY_EDITOR
+        static int s_TextureCacheIdGenerator = 0;
+        int m_TextureCacheId = 0;
-    #if UNITY_EDITOR
+        static bool s_ForceReinjectGlobalFirst = false;
+        static bool s_ForceReinjectGlobalSecond = false;
+        static int s_GlobalSecondSetByTexCacheID = -1;
+        
+
+        // here we receive the in-editor updated textures. These must be reinjected into 
+        // any texture cache which has a stale copy of it. However, we don't have a this-pointer to the texture cache
+        // so instead we defer this to NewFrame() where we force reinject.
+        // Ideally we'd build up a list here of textures which are to be reinjected but unfortunately the texture we receive
+        // is an intermediate one and not the final compressed one. So instead we will have to reinject all in NewFrame().
-                s_GlobalTextureCacheVersion++;
+                s_ForceReinjectGlobalFirst = true;
+                s_ForceReinjectGlobalSecond = false;
+                s_GlobalSecondSetByTexCacheID = -1;
-    #endif
+#endif
 
         public static bool isMobileBuildTarget
         {
             {
                 sliceIndex = m_LocatorInSliceArray[texId];
                 bFoundAvailOrExistingSlice = true;
-#if UNITY_EDITOR
-                if(m_TextureCacheVersion!=s_GlobalTextureCacheVersion)
-                {
-                    m_TextureCacheVersion++;
-                    Debug.Assert(m_TextureCacheVersion <= s_GlobalTextureCacheVersion);
-                    bSwapSlice = true;  // force a reinject.
-                }
-#endif
                 //assert(m_SliceArray[sliceIndex].TexID==TexID);
             }
 
 
             //for(int q=1; q<m_numTextures; q++)
             //    assert(m_SliceArray[m_SortedIdxArray[q-1]].CountLRU>=m_SliceArray[m_SortedIdxArray[q]].CountLRU);
+
+
+#if UNITY_EDITOR
+            // one or more textures got updated in editor. Unfortunately we do not know exactly which since
+            // OnPostprocessTexture() receives intermediate uncompressed textures. So we will have to reinject all slices to force an update.
+            if(s_ForceReinjectGlobalSecond && s_GlobalSecondSetByTexCacheID==m_TextureCacheId)
+            {
+                s_ForceReinjectGlobalSecond = false;
+                s_GlobalSecondSetByTexCacheID = -1;
+            }
+
+            if(s_ForceReinjectGlobalFirst)
+            {
+                s_ForceReinjectGlobalSecond = true;
+                s_GlobalSecondSetByTexCacheID = m_TextureCacheId;
+                s_ForceReinjectGlobalFirst = false;
+            }
+            
+            if(s_ForceReinjectGlobalSecond)
+            {
+                // all texture caches must loop through and force a reinject on all entries when this is true.
+                for(int i = 0; i < m_NumTextures; i++)
+                {
+                    var texID = m_SliceArray[i].texId;
+                    if(texID!=g_InvalidTexID)
+                    {
+                        Texture texture = (Texture) EditorUtility.InstanceIDToObject((int) texID);
+                        if(texture!=null) TransferToSlice(i, texture);
+                    }
+                }
+            }
+#endif
         }
 
         protected TextureCache()
+
+#if UNITY_EDITOR
+            m_TextureCacheId = s_TextureCacheIdGenerator;       // assign an ID so we can tell the caches apart
+            ++s_TextureCacheIdGenerator;        // static/global
+#endif
         }
 
         public virtual void TransferToSlice(int sliceIndex, Texture texture)

Assets/ScriptableRenderPipeline/Fptl/FptlLighting.cs

             cmd.SetComputeBufferParam(buildPerVoxelLightListShader, s_ClearVoxelAtomicKernel, "g_LayeredSingleIdxBuffer", s_GlobalLightListAtomic);
             cmd.DispatchCompute(buildPerVoxelLightListShader, s_ClearVoxelAtomicKernel, 1, 1, 1);
 
+            bool isOrthographic = camera.orthographic;
+            cmd.SetComputeIntParam(buildPerVoxelLightListShader, "g_isOrthographic", isOrthographic ? 1 : 0);
             cmd.SetComputeIntParam(buildPerVoxelLightListShader, "g_iNrVisibLights", numLights);
             cmd.SetComputeMatrixParam(buildPerVoxelLightListShader, "g_mScrProjection", projscr);
             cmd.SetComputeMatrixParam(buildPerVoxelLightListShader, "g_mInvScrProjection", invProjscr);
 
             var cmd = CommandBufferPool.Get("Build light list" );
 
+            bool isOrthographic = camera.orthographic;
+
             // generate screen-space AABBs (used for both fptl and clustered).
             if (numLights != 0)
             {
                 var projh = temp * proj;
                 var invProjh = projh.inverse;
 
+                cmd.SetComputeIntParam(buildScreenAABBShader, "g_isOrthographic", isOrthographic ? 1 : 0);
                 cmd.SetComputeIntParam(buildScreenAABBShader, "g_iNrVisibLights", numLights);
                 cmd.SetComputeMatrixParam(buildScreenAABBShader, "g_mProjection", projh);
                 cmd.SetComputeMatrixParam(buildScreenAABBShader, "g_mInvProjection", invProjh);
             // enable coarse 2D pass on 64x64 tiles (used for both fptl and clustered).
             if (enableBigTilePrepass)
             {
+                cmd.SetComputeIntParam(buildPerBigTileLightListShader, "g_isOrthographic", isOrthographic ? 1 : 0);
                 cmd.SetComputeIntParams(buildPerBigTileLightListShader, "g_viDimensions", new int[2] { w, h });
                 cmd.SetComputeIntParam(buildPerBigTileLightListShader, "g_iNrVisibLights", numLights);
                 cmd.SetComputeMatrixParam(buildPerBigTileLightListShader, "g_mScrProjection", projscr);
 
             if (usingFptl)        // optimized for opaques only
             {
+                cmd.SetComputeIntParam(buildPerTileLightListShader, "g_isOrthographic", isOrthographic ? 1 : 0);
                 cmd.SetComputeIntParams(buildPerTileLightListShader, "g_viDimensions", new int[2] { w, h });
                 cmd.SetComputeIntParam(buildPerTileLightListShader, "g_iNrVisibLights", numLights);
                 cmd.SetComputeMatrixParam(buildPerTileLightListShader, "g_mScrProjection", projscr);
         void PushGlobalParams(Camera camera, ScriptableRenderContext loop, Matrix4x4 viewToWorld, Matrix4x4 scrProj, Matrix4x4 incScrProj, int numDirLights)
         {
             var cmd = CommandBufferPool.Get("Push Global Parameters");
-
+                  
+            bool isOrthographic = camera.orthographic;
+            cmd.SetGlobalFloat("g_isOrthographic", (float) (isOrthographic ? 1 : 0));
             cmd.SetGlobalFloat("g_widthRT", (float)camera.pixelWidth);
             cmd.SetGlobalFloat("g_heightRT", (float)camera.pixelHeight);
 

Assets/ScriptableRenderPipeline/Fptl/LightingConvexHullUtils.hlsl

     return float4(vN, -dot(vN,p0));
 }
 
-bool DoesSphereOverlapTile(float3 dir, float halfTileSizeAtZDistOne, float3 sphCen, float sphRadiusIn)
+bool DoesSphereOverlapTile(float3 dir, float halfTileSizeAtZDistOne, float3 sphCen_in, float sphRadiusIn, bool isOrthographic)
-    float3 V = dir;     // ray direction down center of tile (does not need to be normalized).
+    float3 V = float3(isOrthographic ? 0.0 : dir.x, isOrthographic ? 0.0 : dir.y, dir.z);     // ray direction down center of tile (does not need to be normalized).
+	float3 sphCen = float3(sphCen_in.x - (isOrthographic ? dir.x : 0.0), sphCen_in.y - (isOrthographic ? dir.y : 0.0), sphCen_in.z); 
 
 #if 1
     float3 maxZdir = float3(-sphCen.z*sphCen.x, -sphCen.z*sphCen.y, sphCen.x*sphCen.x + sphCen.y*sphCen.y);     // cross(sphCen,cross(Zaxis,sphCen))
 
     // enlarge sphere so it overlaps the center of the tile assuming it overlaps the tile to begin with.
 #if USE_LEFTHAND_CAMERASPACE
-    float sphRadius = sphRadiusIn + (sphCen.z+offs)*halfTileSizeAtZDistOne;
+	float s = sphCen.z+offs;
-    float sphRadius = sphRadiusIn - (sphCen.z-offs)*halfTileSizeAtZDistOne;
+	float s = -(sphCen.z-offs);
+	float sphRadius = sphRadiusIn + (isOrthographic ? 1.0 : s)*halfTileSizeAtZDistOne;
 
     float a = dot(V,V);
     float CdotV = dot(sphCen,V);

Assets/ScriptableRenderPipeline/Fptl/LightingTemplate.hlsl

         DirectionalLight lightData = g_dirLightData[i];
         float atten = 1;
 
+        UnityLight light;
+        light.dir.xyz = mul((float3x3) g_mViewToWorld, -lightData.lightAxisZ).xyz;
+
-			float shadow = GetDirectionalShadowAttenuation(shadowContext, vPw, 0.0.xxx, shadowIdx, 0.0.xxx);
+			float shadow = GetDirectionalShadowAttenuation(shadowContext, vPw, 0.0.xxx, shadowIdx, normalize(light.dir.xyz));
-        UnityLight light;
-        light.dir.xyz = mul((float3x3) g_mViewToWorld, -lightData.lightAxisZ).xyz;
 
         ints += EvalMaterial(light, ind);
     }
             }
             atten *= angularAtt.w*(fProjVec>0.0);                           // finally apply this to the dist att.
 
+            UnityLight light;
+            light.dir.xyz = mul((float3x3) g_mViewToWorld, vL).xyz;     //unity_CameraToWorld
+
-				float shadow = GetPunctualShadowAttenuation(shadowContext, vPw, 0.0.xxx, shadowIdx, 0.0.xxx);
+				float shadow = GetPunctualShadowAttenuation(shadowContext, vPw, 0.0.xxx, shadowIdx, float4(normalize(light.dir.xyz), dist));
-            UnityLight light;
-            light.dir.xyz = mul((float3x3) g_mViewToWorld, vL).xyz;     //unity_CameraToWorld
 
             ints += EvalMaterial(light, ind);
 
 			[branch]
 			if (shadowIdx >= 0)
 			{
-				float shadow = GetPunctualShadowAttenuation(shadowContext, vPw, 0.0.xxx, shadowIdx, vLw);
+				float shadow = GetPunctualShadowAttenuation(shadowContext, vPw, 0.0.xxx, shadowIdx, float4(vLw, dist));
 				atten *= shadow;
 			}
 

Assets/ScriptableRenderPipeline/Fptl/LightingUtils.hlsl

 uniform float4x4 g_mInvScrProjection;
 
 
+uniform uint g_isOrthographic;
 uniform uint g_widthRT;
 uniform uint g_heightRT;
 
-    float fSx = g_mScrProjection[0].x;
-    //float fCx = g_mScrProjection[2].x;
-    float fCx = g_mScrProjection[0].z;
-    float fSy = g_mScrProjection[1].y;
-    //float fCy = g_mScrProjection[2].y;
-    float fCy = g_mScrProjection[1].z;
+	bool isOrthographic = g_isOrthographic!=0;
+	float fSx = g_mScrProjection[0].x;
+	float fSy = g_mScrProjection[1].y;
+	float fCx = isOrthographic ? g_mScrProjection[0].w : g_mScrProjection[0].z;
+	float fCy = isOrthographic ? g_mScrProjection[1].w : g_mScrProjection[1].z;
-    return fLinDepth*float3( ((v2ScrPos.x-fCx)/fSx), ((v2ScrPos.y-fCy)/fSy), 1.0 );
+	bool useLeftHandVersion = true;
-    return fLinDepth*float3( -((v2ScrPos.x+fCx)/fSx), -((v2ScrPos.y+fCy)/fSy), 1.0 );
+	bool useLeftHandVersion = isOrthographic;
+
+	float s = useLeftHandVersion ? 1 : (-1);
+	float2 p = float2( (s*v2ScrPos.x-fCx)/fSx, (s*v2ScrPos.y-fCy)/fSy);
+
+	return float3(isOrthographic ? p.xy : (fLinDepth*p.xy), fLinDepth);
 }
 
 float GetLinearZFromSVPosW(float posW)
 
 float GetLinearDepth(float zDptBufSpace)    // 0 is near 1 is far
 {
-    // todo (simplify): m22 is zero and m23 is +1/-1 (depends on left/right hand proj)
+    // for perspective projection m22 is zero and m23 is +1/-1 (depends on left/right hand proj)
+	// however this function must also work for orthographic projection so we keep it like this.
     float m22 = g_mInvScrProjection[2].z, m23 = g_mInvScrProjection[2].w;
     float m32 = g_mInvScrProjection[3].z, m33 = g_mInvScrProjection[3].w;
 

Assets/ScriptableRenderPipeline/Fptl/ShadowDispatch.hlsl

 
 // example of overriding punctual lights
 #ifdef  SHADOW_DISPATCH_USE_CUSTOM_PUNCTUAL
-float GetPunctualShadowAttenuation( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float3 L )
+float GetPunctualShadowAttenuation( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float4 L )
 {
 	// example for choosing the same algo 
 	Texture2DArray			tex = shadowContext.tex2DArray[0];
 }
-float GetPunctualShadowAttenuation( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float3 L, float2 unPositionSS )
+float GetPunctualShadowAttenuation( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float4 L, float2 unPositionSS )
 {
 	return GetPunctualShadowAttenuation( shadowContext, positionWS, normalWS, shadowDataIndex, L );
 }

Assets/ScriptableRenderPipeline/Fptl/lightlistbuild-bigtile.compute

 #define MAX_NR_BIGTILE_LIGHTS				(MAX_NR_BIGTILE_LIGHTS_PLUSONE-1)
 
 
+uniform int g_isOrthographic;
 uniform int g_iNrVisibLights;
 uniform uint2 g_viDimensions;
 uniform float4x4 g_mInvScrProjection;
 
 float3 GetViewPosFromLinDepth(float2 v2ScrPos, float fLinDepth)
 {
+	bool isOrthographic = g_isOrthographic!=0;
-	float fCx = g_mScrProjection[0].z;
-	float fCy = g_mScrProjection[1].z;
+	float fCx = isOrthographic ? g_mScrProjection[0].w : g_mScrProjection[0].z;
+	float fCy = isOrthographic ? g_mScrProjection[1].w : g_mScrProjection[1].z;
-	return fLinDepth*float3( ((v2ScrPos.x-fCx)/fSx), ((v2ScrPos.y-fCy)/fSy), 1.0 );
+	bool useLeftHandVersion = true;
-	return fLinDepth*float3( -((v2ScrPos.x+fCx)/fSx), -((v2ScrPos.y+fCy)/fSy), 1.0 );
+	bool useLeftHandVersion = isOrthographic;
+
+	float s = useLeftHandVersion ? 1 : (-1);
+	float2 p = float2( (s*v2ScrPos.x-fCx)/fSx, (s*v2ScrPos.y-fCy)/fSy);
+
+	return float3(isOrthographic ? p.xy : (fLinDepth*p.xy), fLinDepth);
 }
 
 float GetOnePixDiagWorldDistAtDepthOne()
 	{
 		SFiniteLightBound lgtDat = g_data[lightsListLDS[l]];
 
-		if( !DoesSphereOverlapTile(V, halfTileSizeAtZDistOne, lgtDat.center.xyz, lgtDat.radius) )
+		if( !DoesSphereOverlapTile(V, halfTileSizeAtZDistOne, lgtDat.center.xyz, lgtDat.radius, g_isOrthographic!=0) )
 			lightsListLDS[l]=0xffffffff;
 	}
 
 
 	int i=iSwizzle + (2*(iSection&0x2));	// offset by 4 at section 2
 	vP0 = GetTileVertex(uint2(viTilLL.x, viTilUR.y), uint2(viTilUR.x, viTilLL.y), i, fTileFarPlane);
-	vE0 = iSection == 0 ? vP0 : (((iSwizzle & 0x2) == 0 ? 1.0f : (-1.0f)) * ((int)(iSwizzle & 0x1) == (iSwizzle >> 1) ? float3(1, 0, 0) : float3(0, 1, 0)));
+
+#if USE_LEFTHAND_CAMERASPACE
+	float3 edgeSectionZero = g_isOrthographic==0 ? vP0 : float3(0.0,0.0,1.0); 
+#else
+	float3 edgeSectionZero = g_isOrthographic==0 ? vP0 : float3(0.0,0.0,-1.0); 
+#endif
+
+	vE0 = iSection == 0 ? edgeSectionZero : (((iSwizzle & 0x2) == 0 ? 1.0f : (-1.0f)) * ((int)(iSwizzle & 0x1) == (iSwizzle >> 1) ? float3(1, 0, 0) : float3(0, 1, 0)));
 }
 
 void CullByExactEdgeTests(uint threadID, int iNrCoarseLights, uint2 viTilLL, uint2 viTilUR)

Assets/ScriptableRenderPipeline/Fptl/lightlistbuild-clustered.compute

 #define PERFORM_SPHERICAL_INTERSECTION_TESTS
 #define CONV_HULL_TEST_ENABLED
 
+uniform int g_isOrthographic;
 uniform int g_iNrVisibLights;
 uniform float4x4 g_mInvScrProjection;
 uniform float4x4 g_mScrProjection;
 
 float3 GetViewPosFromLinDepth(float2 v2ScrPos, float fLinDepth)
 {
+	bool isOrthographic = g_isOrthographic!=0;
-	float fCx = g_mScrProjection[0].z;
-	float fCy = g_mScrProjection[1].z;
+	float fCx = isOrthographic ? g_mScrProjection[0].w : g_mScrProjection[0].z;
+	float fCy = isOrthographic ? g_mScrProjection[1].w : g_mScrProjection[1].z;
-	return fLinDepth*float3( ((v2ScrPos.x-fCx)/fSx), ((v2ScrPos.y-fCy)/fSy), 1.0 );
+	bool useLeftHandVersion = true;
-	return fLinDepth*float3( -((v2ScrPos.x+fCx)/fSx), -((v2ScrPos.y+fCy)/fSy), 1.0 );
+	bool useLeftHandVersion = isOrthographic;
+
+	float s = useLeftHandVersion ? 1 : (-1);
+	float2 p = float2( (s*v2ScrPos.x-fCx)/fSx, (s*v2ScrPos.y-fCy)/fSy);
+
+	return float3(isOrthographic ? p.xy : (fLinDepth*p.xy), fLinDepth);
 }
 
 float GetOnePixDiagWorldDistAtDepthOne()
 	{
 		SFiniteLightBound lgtDat = g_data[coarseList[l]];
 
-		if( !DoesSphereOverlapTile(V, halfTileSizeAtZDistOne, lgtDat.center.xyz, lgtDat.radius) )
+		if( !DoesSphereOverlapTile(V, halfTileSizeAtZDistOne, lgtDat.center.xyz, lgtDat.radius, g_isOrthographic!=0) )
 			coarseList[l]=0xffffffff;
 	}
 
 
 	int i=iSwizzle + (2*(iSection&0x2));	// offset by 4 at section 2
 	vP0 = GetTileVertex(uint2(viTilLL.x, viTilUR.y), uint2(viTilUR.x, viTilLL.y), i, fTileFarPlane);
-	vE0 = iSection==0 ? vP0 : (((iSwizzle&0x2)==0 ? 1.0f : (-1.0f))*((iSwizzle&0x1)==(iSwizzle>>1) ? float3(1,0,0) : float3(0,1,0)));
+
+#if USE_LEFTHAND_CAMERASPACE
+	float3 edgeSectionZero = g_isOrthographic==0 ? vP0 : float3(0.0,0.0,1.0); 
+#else
+	float3 edgeSectionZero = g_isOrthographic==0 ? vP0 : float3(0.0,0.0,-1.0); 
+#endif
+
+	vE0 = iSection==0 ? edgeSectionZero : (((iSwizzle&0x2)==0 ? 1.0f : (-1.0f))*((iSwizzle&0x1)==(iSwizzle>>1) ? float3(1,0,0) : float3(0,1,0)));
 }
 
 int CullByExactEdgeTests(uint threadID, int iNrCoarseLights, uint2 viTilLL, uint2 viTilUR, float fTileFarPlane)

Assets/ScriptableRenderPipeline/Fptl/lightlistbuild.compute

 #define PERFORM_SPHERICAL_INTERSECTION_TESTS
 
 
+uniform int g_isOrthographic;
 uniform int g_iNrVisibLights;
 uniform uint2 g_viDimensions;
 uniform float4x4 g_mInvScrProjection;
 
 float3 GetViewPosFromLinDepth(float2 v2ScrPos, float fLinDepth)
 {
+	bool isOrthographic = g_isOrthographic!=0;
-	float fCx = g_mScrProjection[0].z;
-	float fCy = g_mScrProjection[1].z;
+	float fCx = isOrthographic ? g_mScrProjection[0].w : g_mScrProjection[0].z;
+	float fCy = isOrthographic ? g_mScrProjection[1].w : g_mScrProjection[1].z;
-	return fLinDepth*float3( ((v2ScrPos.x-fCx)/fSx), ((v2ScrPos.y-fCy)/fSy), 1.0 );
+	bool useLeftHandVersion = true;
-	return fLinDepth*float3( -((v2ScrPos.x+fCx)/fSx), -((v2ScrPos.y+fCy)/fSy), 1.0 );
+	bool useLeftHandVersion = isOrthographic;
+
+	float s = useLeftHandVersion ? 1 : (-1);
+	float2 p = float2( (s*v2ScrPos.x-fCx)/fSx, (s*v2ScrPos.y-fCy)/fSy);
+
+	return float3(isOrthographic ? p.xy : (fLinDepth*p.xy), fLinDepth);
 }
 
 float GetOnePixDiagWorldDistAtDepthOne()
 	{
 		SFiniteLightBound lightData = g_data[prunedList[l]];
 
-		if( DoesSphereOverlapTile(V, halfTileSizeAtZDistOne, lightData.center.xyz, lightData.radius) )
+		if( DoesSphereOverlapTile(V, halfTileSizeAtZDistOne, lightData.center.xyz, lightData.radius, g_isOrthographic!=0) )
 		{
 			unsigned int uIndex;
 			InterlockedAdd(lightOffsSph, 1, uIndex);

Assets/ScriptableRenderPipeline/Fptl/scrbound.compute

 #include "ShaderBase.h"
 #include "LightDefinitions.cs.hlsl"
 
+uniform int g_isOrthographic;
 uniform int g_iNrVisibLights;
 uniform float4x4 g_mInvProjection;
 uniform float4x4 g_mProjection;
 			}
 			else
 			{
-				//if((center.z+radius)<0.0)
-				if( length(center)>radius)
+				if(g_isOrthographic==0 && length(center)>radius)
 				{
 					float2 vMi, vMa;
 					bool2 bMi, bMa;
 					vMax.xy = bMa ? min(vMax.xy, vMa) : vMax.xy;
+				}
+				else if(g_isOrthographic!=0)
+				{
+					float2 vMi = mul(g_mProjection, float4(center.xyz-radius,1)).xy;	 // no division needed for ortho
+					float2 vMa = mul(g_mProjection, float4(center.xyz+radius,1)).xy;	 // no division needed for ortho
+					vMin.xy = max(vMin.xy, vMi);
+					vMax.xy = min(vMax.xy, vMa);
 				}
 
 #if USE_LEFTHAND_CAMERASPACE

Assets/ScriptableRenderPipeline/HDRenderPipeline/Debug/DebugDisplay.cs

         public static string kFullScreenDebugMode = "Fullscreen Debug Mode";
         public static string kDisplaySkyReflectionDebug = "Display Sky Reflection";
         public static string kSkyReflectionMipmapDebug = "Sky Reflection Mipmap";
+        public static string kTileDebug = "Tile Debug By Category";
 
 
         public float debugOverlayRatio = 0.33f;
         public static int[] debugViewEngineValues = null;
         public static GUIContent[] debugViewMaterialVaryingStrings = null;
         public static int[] debugViewMaterialVaryingValues = null;
+        public static GUIContent[] debugViewMaterialPropertiesStrings = null;
+        public static int[] debugViewMaterialPropertiesValues = null;
         public static GUIContent[] debugViewMaterialGBufferStrings = null;
         public static int[] debugViewMaterialGBufferValues = null;
 
             materialDebugSettings.SetDebugViewVarying(value);
         }
 
+        public void SetDebugViewProperties(Attributes.DebugViewProperties value)
+        {
+            if (value != 0)
+                lightingDebugSettings.debugLightingMode = DebugLightingMode.None;
+            materialDebugSettings.SetDebugViewProperties(value);
+        }
+
         public void SetDebugViewGBuffer(int value)
         {
             if (value != 0)
             DebugMenuManager.instance.AddDebugItem<int>("Material", "Material",() => materialDebugSettings.debugViewMaterial, (value) => SetDebugViewMaterial((int)value), DebugItemFlag.None, new DebugItemHandlerIntEnum(DebugDisplaySettings.debugViewMaterialStrings, DebugDisplaySettings.debugViewMaterialValues));
             DebugMenuManager.instance.AddDebugItem<int>("Material", "Engine",() => materialDebugSettings.debugViewEngine, (value) => SetDebugViewEngine((int)value), DebugItemFlag.None, new DebugItemHandlerIntEnum(DebugDisplaySettings.debugViewEngineStrings, DebugDisplaySettings.debugViewEngineValues));
             DebugMenuManager.instance.AddDebugItem<Attributes.DebugViewVarying>("Material", "Attributes",() => materialDebugSettings.debugViewVarying, (value) => SetDebugViewVarying((Attributes.DebugViewVarying)value));
+            DebugMenuManager.instance.AddDebugItem<Attributes.DebugViewProperties>("Material", "Properties", () => materialDebugSettings.debugViewProperties, (value) => SetDebugViewProperties((Attributes.DebugViewProperties)value));
             DebugMenuManager.instance.AddDebugItem<int>("Material", "GBuffer",() => materialDebugSettings.debugViewGBuffer, (value) => SetDebugViewGBuffer((int)value), DebugItemFlag.None, new DebugItemHandlerIntEnum(DebugDisplaySettings.debugViewMaterialGBufferStrings, DebugDisplaySettings.debugViewMaterialGBufferValues));
 
             DebugMenuManager.instance.AddDebugItem<LightingDebugPanel, bool>(kEnableShadowDebug, () => lightingDebugSettings.enableShadows, (value) => lightingDebugSettings.enableShadows = (bool)value);
             DebugMenuManager.instance.AddDebugItem<LightingDebugPanel, Color>(kDebugLightingAlbedo, () => lightingDebugSettings.debugLightingAlbedo, (value) => lightingDebugSettings.debugLightingAlbedo = (Color)value);
             DebugMenuManager.instance.AddDebugItem<bool>("Lighting", kDisplaySkyReflectionDebug, () => lightingDebugSettings.displaySkyReflection, (value) => lightingDebugSettings.displaySkyReflection = (bool)value);
             DebugMenuManager.instance.AddDebugItem<LightingDebugPanel, float>(kSkyReflectionMipmapDebug, () => lightingDebugSettings.skyReflectionMipmap, (value) => lightingDebugSettings.skyReflectionMipmap = (float)value, DebugItemFlag.None, new DebugItemHandlerFloatMinMax(0.0f, 1.0f));
+            DebugMenuManager.instance.AddDebugItem<LightingDebugPanel, TilePass.TileSettings.TileDebug>(kTileDebug,() => lightingDebugSettings.tileDebugByCategory, (value) => lightingDebugSettings.tileDebugByCategory = (TilePass.TileSettings.TileDebug)value);
 
             DebugMenuManager.instance.AddDebugItem<bool>("Rendering", "Display Opaque",() => renderingDebugSettings.displayOpaqueObjects, (value) => renderingDebugSettings.displayOpaqueObjects = (bool)value);
             DebugMenuManager.instance.AddDebugItem<bool>("Rendering", "Display Transparency",() => renderingDebugSettings.displayTransparentObjects, (value) => renderingDebugSettings.displayTransparentObjects = (bool)value);
                 index = 0;
                 FillWithPropertiesEnum(typeof(Attributes.DebugViewVarying), debugViewMaterialVaryingStrings, debugViewMaterialVaryingValues, "", ref index);
 
+                // Properties debug
+                var propertiesNames = Enum.GetNames(typeof(Attributes.DebugViewProperties));
+                debugViewMaterialPropertiesStrings = new GUIContent[propertiesNames.Length];
+                debugViewMaterialPropertiesValues = new int[propertiesNames.Length];
+                index = 0;
+                FillWithPropertiesEnum(typeof(Attributes.DebugViewProperties), debugViewMaterialPropertiesStrings, debugViewMaterialPropertiesValues, "", ref index);
+
                 // Gbuffer debug
                 var gbufferNames = Enum.GetNames(typeof(Attributes.DebugViewGbuffer));
                 debugViewMaterialGBufferStrings = new GUIContent[gbufferNames.Length + bsdfDataDeferredType.GetFields().Length];
             Depth = DebugViewVarying.VertexColorAlpha + 1,
             BakeDiffuseLightingWithAlbedoPlusEmissive,
         }
+
+        // Number must be contiguous
+        [GenerateHLSL]
+        public enum DebugViewProperties
+        {
+            None = 0,
+            Tessellation = DebugViewGbuffer.BakeDiffuseLightingWithAlbedoPlusEmissive + 1,
+            PerPixelDisplacement,
+            DepthOffset,
+            Lightmap,
+        }
     }
 
     [Serializable]
         public int debugViewEngine { get { return m_DebugViewEngine; } }
         public Attributes.DebugViewVarying debugViewVarying { get { return m_DebugViewVarying; } }
+        public Attributes.DebugViewProperties debugViewProperties { get { return m_DebugViewProperties; } }
+        Attributes.DebugViewProperties  m_DebugViewProperties = Attributes.DebugViewProperties.None;
         int                             m_DebugViewGBuffer = 0; // Can't use GBuffer enum here because the values are actually split between this enum and values from Lit.BSDFData
 
         public int GetDebugMaterialIndex()
             // They are all mutually exclusive so return the sum will return the right index.
-            return m_DebugViewGBuffer + m_DebugViewMaterial + m_DebugViewEngine + (int)m_DebugViewVarying;
+            return m_DebugViewGBuffer + m_DebugViewMaterial + m_DebugViewEngine + (int)m_DebugViewVarying + (int)m_DebugViewProperties;
         }
 
         public void DisableMaterialDebug()
             m_DebugViewVarying = Attributes.DebugViewVarying.None;
+            m_DebugViewProperties = Attributes.DebugViewProperties.None;
             m_DebugViewGBuffer = 0;
         }
 
                 DisableMaterialDebug();
             m_DebugViewVarying = value;
         }
+        public void SetDebugViewProperties(Attributes.DebugViewProperties value)
+        {
+            if (value != 0)
+                DisableMaterialDebug();
+            m_DebugViewProperties = value;
+        }
 
         public void SetDebugViewGBuffer(int value)
         {
 
         public bool IsDebugDisplayEnabled()
         {
-            return (m_DebugViewEngine != 0 || m_DebugViewMaterial != 0 || m_DebugViewVarying != Attributes.DebugViewVarying.None || m_DebugViewGBuffer != 0);
+            return (m_DebugViewEngine != 0 || m_DebugViewMaterial != 0 || m_DebugViewVarying != Attributes.DebugViewVarying.None || m_DebugViewProperties != Attributes.DebugViewProperties.None || m_DebugViewGBuffer != 0);
         }
     }
 
         None,
         SSAO,
         SSAOBeforeFiltering,
+        MotionVectors,
+        NanTracker
     }
 
     [Serializable]
 
         public bool                 displaySkyReflection = false;
         public float                skyReflectionMipmap = 0.0f;
+
+        public TilePass.TileSettings.TileDebug  tileDebugByCategory = TilePass.TileSettings.TileDebug.None;
 
         public void OnValidate()
         {

Assets/ScriptableRenderPipeline/HDRenderPipeline/Debug/DebugDisplay.cs.hlsl

 #define DEBUGVIEWGBUFFER_BAKE_DIFFUSE_LIGHTING_WITH_ALBEDO_PLUS_EMISSIVE (11)
 
 //
+// UnityEngine.Experimental.Rendering.HDPipeline.Attributes.DebugViewProperties:  static fields
+//
+#define DEBUGVIEWPROPERTIES_NONE (0)
+#define DEBUGVIEWPROPERTIES_TESSELLATION (12)
+#define DEBUGVIEWPROPERTIES_PER_PIXEL_DISPLACEMENT (13)
+#define DEBUGVIEWPROPERTIES_DEPTH_OFFSET (14)
+#define DEBUGVIEWPROPERTIES_LIGHTMAP (15)
+
+//
+#define FULLSCREENDEBUGMODE_MOTION_VECTORS (3)
+#define FULLSCREENDEBUGMODE_NAN_TRACKER (4)
 
 
 #endif

Assets/ScriptableRenderPipeline/HDRenderPipeline/Debug/DebugDisplay.hlsl

 float4 _DebugLightingAlbedo; // xyz = albedo for diffuse, w unused
 float4 _DebugLightingSmoothness; // x == bool override, y == override value
 
+void GetPropertiesDataDebug(uint paramId, inout float3 result, inout bool needLinearToSRGB)
+{
+    switch (paramId)
+    {
+        case DEBUGVIEWPROPERTIES_TESSELLATION:
+#ifdef TESSELLATION_ON
+            result = float3(1.0, 0.0, 0.0);
+#else
+            result = float3(0.0, 0.0, 0.0);
+#endif
+            break;
+
+        case DEBUGVIEWPROPERTIES_PER_PIXEL_DISPLACEMENT:
+#ifdef _PER_PIXEL_DISPLACEMENT // Caution: This define is related to a shader features (But it may become a standard features for HD
+            result = float3(1.0, 0.0, 0.0);
+#else
+            result = float3(0.0, 0.0, 0.0);
+#endif
+            break;
+
+        case DEBUGVIEWPROPERTIES_DEPTH_OFFSET:
+#ifdef _DEPTHOFFSET_ON  // Caution: This define is related to a shader features (But it may become a standard features for HD
+            result = float3(1.0, 0.0, 0.0);
+#else
+            result = float3(0.0, 0.0, 0.0);
+#endif
+            break;
+
+        case DEBUGVIEWPROPERTIES_LIGHTMAP:
+#if defined(LIGHTMAP_ON) || defined (DIRLIGHTMAP_COMBINED) || defined(DYNAMICLIGHTMAP_ON)
+            result = float3(1.0, 0.0, 0.0);
+#else
+            result = float3(0.0, 0.0, 0.0);
+#endif
+            break;
+
+    }
+}
+
 #endif

Assets/ScriptableRenderPipeline/HDRenderPipeline/Debug/DebugFullScreen.shader

 
             #include "../../ShaderLibrary/Common.hlsl"
             #include "../Debug/DebugDisplay.cs.hlsl"
+            #include "../ShaderVariables.hlsl"
 
             TEXTURE2D(_DebugFullScreenTexture);
             SAMPLER2D(sampler_DebugFullScreenTexture);
                 return output;
             }
 
+            // Motion vector debug utilities
+            // >>>
+            float DistanceToLine(float2 p, float2 p1, float2 p2)
+            {
+                float2 center = (p1 + p2) * 0.5;
+                float len = length(p2 - p1);
+                float2 dir = (p2 - p1) / len;
+                float2 rel_p = p - center;
+                return dot(rel_p, float2(dir.y, -dir.x));
+            }
+
+            float DistanceToSegment(float2 p, float2 p1, float2 p2)
+            {
+                float2 center = (p1 + p2) * 0.5;
+                float len = length(p2 - p1);
+                float2 dir = (p2 - p1) / len;
+                float2 rel_p = p - center;
+                float dist1 = abs(dot(rel_p, float2(dir.y, -dir.x)));
+                float dist2 = abs(dot(rel_p, dir)) - 0.5 * len;
+                return max(dist1, dist2);
+            }
+
+            float DrawArrow(float2 texcoord, float body, float head, float height, float linewidth, float antialias)
+            {
+                float w = linewidth / 2.0 + antialias;
+                float2 start = -float2(body / 2.0, 0.0);
+                float2 end = float2(body / 2.0, 0.0);
+
+                // Head: 3 lines
+                float d1 = DistanceToLine(texcoord, end, end - head * float2(1.0, -height));
+                float d2 = DistanceToLine(texcoord, end - head * float2(1.0, height), end);
+                float d3 = texcoord.x - end.x + head;
+
+                // Body: 1 segment
+                float d4 = DistanceToSegment(texcoord, start, end - float2(linewidth, 0.0));
+
+                float d = min(max(max(d1, d2), -d3), d4);
+                return d;
+            }
+
+            float2 SampleMotionVectors(float2 coords)
+            {
+            #if UNITY_UV_STARTS_AT_TOP
+                coords.y = 1.0 - coords.y;
+            #endif
+
+                float2 mv = SAMPLE_TEXTURE2D(_DebugFullScreenTexture, sampler_DebugFullScreenTexture, coords).xy;
+
+            #if UNITY_UV_STARTS_AT_TOP
+                mv.y *= -1.0;
+            #endif
+
+                return mv;
+            }
+            // <<<
+
             float4 Frag(Varyings input) : SV_Target
             {
                 // SSAO
                 if (_FullScreenDebugMode == FULLSCREENDEBUGMODE_SSAOBEFORE_FILTERING)
                 {
                     return 1.0f - SAMPLE_TEXTURE2D(_DebugFullScreenTexture, sampler_DebugFullScreenTexture, input.texcoord).xxxx;
+                }
+                if (_FullScreenDebugMode == FULLSCREENDEBUGMODE_NAN_TRACKER)
+                {
+                #if UNITY_UV_STARTS_AT_TOP
+                    input.texcoord.y = 1.0 - input.texcoord.y;
+                #endif
+
+                    float4 color = SAMPLE_TEXTURE2D(_DebugFullScreenTexture, sampler_DebugFullScreenTexture, input.texcoord);
+
+                    if (any(isnan(color)) || any(isinf(color)))
+                    {
+                        color = float4(1.0, 0.0, 1.0, 1.0);
+                    }
+                    else
+                    {
+                        // Dim the color buffer so we can see NaNs & Infs better
+                        color.rgb *= 0.25;
+                    }
+
+                    return color;
+                }
+                if (_FullScreenDebugMode == FULLSCREENDEBUGMODE_MOTION_VECTORS)
+                {
+                    float2 mv = SampleMotionVectors(input.texcoord);
+
+                    // Background color intensity - keep this low unless you want to make your eyes bleed
+                    const float kIntensity = 0.15;
+
+                    // Map motion vector direction to color wheel (hue between 0 and 360deg)
+                    float phi = atan2(mv.x, mv.y);
+                    float hue = (phi / PI + 1.0) * 0.5;
+                    float r = abs(hue * 6.0 - 3.0) - 1.0;
+                    float g = 2.0 - abs(hue * 6.0 - 2.0);
+                    float b = 2.0 - abs(hue * 6.0 - 4.0);
+
+                    float3 color = saturate(float3(r, g, b) * kIntensity);
+
+                    // Grid subdivisions - should be dynamic
+                    const float kGrid = 64.0;
+
+                    // Arrow grid (aspect ratio is kept)
+                    float rows = floor(kGrid * _ScreenParams.y / _ScreenParams.x);
+                    float cols = kGrid;
+                    float2 size = _ScreenParams.xy / float2(cols, rows);
+                    float body = min(size.x, size.y) / 1.4142135623730951; // sqrt(2)
+                    float2 texcoord = input.positionCS.xy;
+                    float2 center = (floor(texcoord / size) + 0.5) * size;
+                    texcoord -= center;
+
+                    // Sample the center of the cell to get the current arrow vector
+                    float2 arrow_coord = center / _ScreenParams.xy;
+                    float2 mv_arrow = SampleMotionVectors(arrow_coord);
+
+                    // Skip empty motion
+                    float d = 0.0;
+                    if (any(mv_arrow))
+                    {
+                        // Rotate the arrow according to the direction
+                        mv_arrow = normalize(mv_arrow);
+                        float2x2 rot = float2x2(mv_arrow.x, -mv_arrow.y, mv_arrow.y, mv_arrow.x);
+                        texcoord = mul(rot, texcoord);
+
+                        d = DrawArrow(texcoord, body, 0.25 * body, 0.5, 2.0, 1.0);
+                        d = 1.0 - saturate(d);
+                    }
+
+                    return float4(color + d.xxx, 1.0);
                 }
 
                 return float4(0.0, 0.0, 0.0, 0.0);

Assets/ScriptableRenderPipeline/HDRenderPipeline/Debug/DebugViewMaterialGBuffer.shader

 
             // 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/Debug/LightingDebugPanel.cs

 
                 m_DebugPanel.GetDebugItem(DebugDisplaySettings.kFullScreenDebugMode).handler.OnEditorGUI();
 
+                m_DebugPanel.GetDebugItem(DebugDisplaySettings.kTileDebug).handler.OnEditorGUI();
+
                 DebugItem displaySkyReflecItem = m_DebugPanel.GetDebugItem(DebugDisplaySettings.kDisplaySkyReflectionDebug);
                 displaySkyReflecItem.handler.OnEditorGUI();
                 if ((bool)displaySkyReflecItem.GetValue())

Assets/ScriptableRenderPipeline/HDRenderPipeline/Editor/HDRenderPipelineInspector.cs

             // Tile pass Settings
             public readonly GUIContent tileLightLoopSettings = new GUIContent("Tile Light Loop Settings");
             public readonly GUIContent enableTileAndCluster = new GUIContent("Enable tile/clustered", "Toggle");
-            public readonly GUIContent enableSplitLightEvaluation = new GUIContent("Split light and reflection evaluation", "Toggle");
             public readonly GUIContent enableComputeLightEvaluation = new GUIContent("Enable Compute Light Evaluation", "Toggle");
             public readonly GUIContent enableComputeLightVariants = new GUIContent("Enable Compute Light Variants", "Toggle");
             public readonly GUIContent enableComputeMaterialVariants = new GUIContent("Enable Compute Material Variants", "Toggle");
         SerializedProperty m_enableClustered;
         SerializedProperty m_enableFptlForOpaqueWhenClustered;
         SerializedProperty m_enableBigTilePrepass;
-        SerializedProperty m_tileDebugByCategory;
 
         // Rendering Settings
         SerializedProperty m_RenderingUseForwardOnly = null;
 
             // Tile settings
             m_enableTileAndCluster = FindProperty(x => x.tileSettings.enableTileAndCluster);
-            m_enableSplitLightEvaluation = FindProperty(x => x.tileSettings.enableSplitLightEvaluation);
             m_enableComputeLightEvaluation = FindProperty(x => x.tileSettings.enableComputeLightEvaluation);
             m_enableComputeLightVariants = FindProperty(x => x.tileSettings.enableComputeLightVariants);
             m_enableComputeMaterialVariants = FindProperty(x => x.tileSettings.enableComputeMaterialVariants);
-            m_tileDebugByCategory = FindProperty(x => x.tileSettings.tileDebugByCategory);
 
             // Shadow settings
             m_ShadowAtlasWidth = FindProperty(x => x.shadowInitParams.shadowAtlasWidth);
             EditorGUI.BeginChangeCheck();
 
             EditorGUILayout.PropertyField(m_enableTileAndCluster, styles.enableTileAndCluster);
-            EditorGUILayout.PropertyField(m_enableSplitLightEvaluation, styles.enableSplitLightEvaluation);
-            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);
-            EditorGUILayout.PropertyField(m_tileDebugByCategory, styles.tileDebugByCategory);
+            if (m_enableTileAndCluster.boolValue)
+            {
+                EditorGUI.indentLevel++;
+                EditorGUILayout.PropertyField(m_enableBigTilePrepass, styles.enableBigTilePrepass);
+                EditorGUILayout.PropertyField(m_enableClustered, styles.enableClustered);
+                if (m_enableClustered.boolValue)
+                {
+                    EditorGUI.indentLevel++;
+                    EditorGUILayout.PropertyField(m_enableFptlForOpaqueWhenClustered, styles.enableFptlForOpaqueWhenClustered);
+                    EditorGUI.indentLevel--;
+                }
+                EditorGUILayout.PropertyField(m_enableComputeLightEvaluation, styles.enableComputeLightEvaluation);
+                if (m_enableComputeLightEvaluation.boolValue)
+                {
+                    EditorGUI.indentLevel++;
+                    EditorGUILayout.PropertyField(m_enableComputeLightVariants, styles.enableComputeLightVariants);
+                    EditorGUILayout.PropertyField(m_enableComputeMaterialVariants, styles.enableComputeMaterialVariants);
+                    EditorGUI.indentLevel--;
+                }
+            }
+
 
             if (EditorGUI.EndChangeCheck())
             {

Assets/ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipeline.cs

         // View-projection matrix from the previous frame.
         public Matrix4x4 prevViewProjMatrix;
 
+        // We need to keep track of these when camera relative rendering is enabled so we can take
+        // camera translation into account when generating camera motion vectors
+        public Vector3 cameraPos;
+        public Vector3 prevCameraPos;
+
         // The only way to reliably keep track of a frame change right now is to compare the frame
         // count Unity gives us. We need this as a single camera could be rendered several times per
         // frame and some matrices only have to be computed once. Realistically this shouldn't
             Matrix4x4 gpuView = camera.worldToCameraMatrix;
             Matrix4x4 gpuNonJitteredProj = GL.GetGPUProjectionMatrix(nonJitteredCameraProj, true);
 
+            Vector3 pos = camera.transform.position;
+
             if (ShaderConfig.s_CameraRelativeRendering != 0)
             {
                 // Zero out the translation component.
             Matrix4x4 gpuVP = gpuNonJitteredProj * gpuView;
 
-            // A camera could be rendered multiple time per frame, only updates the previous viewproj if needed
+            // A camera could be rendered multiple times per frame, only updates the previous view proj & pos if needed
-                prevViewProjMatrix = !m_FirstFrame
-                    ? nonJitteredViewProjMatrix
-                    : gpuVP;
+                if (m_FirstFrame)
+                {
+                    prevCameraPos = pos;
+                    prevViewProjMatrix = gpuVP;
+                }
+                else
+                {
+                    prevCameraPos = cameraPos;
+                    prevViewProjMatrix = nonJitteredViewProjMatrix;
+                }
 
                 m_FirstFrame = false;
             }
             nonJitteredProjMatrix = gpuNonJitteredProj;
+            cameraPos = pos;
             screenSize = new Vector4(camera.pixelWidth, camera.pixelHeight, 1.0f / camera.pixelWidth, 1.0f / camera.pixelHeight);
 
             Plane[] planes = GeometryUtility.CalculateFrustumPlanes(viewProjMatrix);
                 RenderForward(m_CullResults, camera, renderContext, cmd, true); // Render deferred or forward opaque
                 RenderForwardOnlyOpaque(m_CullResults, camera, renderContext, cmd);
 
-                RenderLightingDebug(hdCamera, cmd, m_CameraColorBufferRT);
+                RenderLightingDebug(hdCamera, cmd, m_CameraColorBufferRT, m_DebugDisplaySettings);
 
                 // If full forward rendering, we did just rendered everything, so we can copy the depth buffer
                 // If Deferred nothing needs copying anymore.
 
                 // Render all type of transparent forward (unlit, lit, complex (hair...)) to keep the sorting between transparent objects.
                 RenderForward(m_CullResults, camera, renderContext, cmd, false);
+
+                PushFullScreenDebugTexture(cmd, m_CameraColorBuffer, camera, renderContext, FullScreenDebugMode.NanTracker);
 
                 // Planar and real time cubemap doesn't need post process and render in FP16
                 if (camera.cameraType == CameraType.Reflection)
             return m_SkyManager.ExportSkyToTexture();
         }
 
-        void RenderLightingDebug(HDCamera camera, CommandBuffer cmd, RenderTargetIdentifier colorBuffer)
+        void RenderLightingDebug(HDCamera camera, CommandBuffer cmd, RenderTargetIdentifier colorBuffer, DebugDisplaySettings debugDisplaySettings)
-            m_LightLoop.RenderLightingDebug(camera, cmd, colorBuffer);
+            m_LightLoop.RenderLightingDebug(camera, cmd, colorBuffer, debugDisplaySettings);
         }
 
         void RenderForward(CullResults cullResults, Camera camera, ScriptableRenderContext renderContext, CommandBuffer cmd, bool renderOpaque)
                 int w = (int)hdcam.screenSize.x;
                 int h = (int)hdcam.screenSize.y;
 
+                m_CameraMotionVectorsMaterial.SetVector("_CameraPosDiff", hdcam.prevCameraPos - hdcam.cameraPos);
+
+
+                PushFullScreenDebugTexture(cmd, m_VelocityBuffer, hdcam.camera, renderContext, FullScreenDebugMode.MotionVectors);
             }
         }
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipelineAsset.asset

     useDisneySSS: 1
   tileSettings:
     enableTileAndCluster: 1
-    enableSplitLightEvaluation: 1
     enableComputeLightEvaluation: 1
     enableComputeLightVariants: 1
     enableComputeMaterialVariants: 1
     diffuseGlobalDimmer: 1
     specularGlobalDimmer: 1
-    tileDebugByCategory: 0
   shadowInitParams:
     shadowAtlasWidth: 4096
     shadowAtlasHeight: 4096

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

             if (settings.enable == false || isForward)
             {
                 cmd.SetGlobalTexture(Uniforms._AOBuffer, UnityEngine.Rendering.PostProcessing.RuntimeUtilities.blackTexture); // Neutral is black, see the comment in the shaders
+                cmd.SetGlobalFloat("_AmbientOcclusionDirectLightStrenght", 0.0f);
                 return;
             }
 
                 Utilities.DrawFullScreen(cmd, m_Material, Uniforms._AOBuffer, null, 3);
                 cmd.ReleaseTemporaryRT(Uniforms._TempTex1);
 
-                // Setup texture for lighting pass (automagic of unity)
+                // Setup texture for lighting pass (automatic of unity)
+                cmd.SetGlobalFloat("_AmbientOcclusionDirectLightStrenght", settings.affectDirectLigthingStrenght);
                 hdRP.PushFullScreenDebugTexture(cmd, Uniforms._AOBuffer, 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

 
 // example of overriding punctual lights
 #ifdef  SHADOW_DISPATCH_USE_CUSTOM_PUNCTUAL
-float GetPunctualShadowAttenuation( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float3 L )
+float GetPunctualShadowAttenuation( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float4 L )
 {
 #ifdef SHADOW_DISPATCH_USE_SEPARATE_PUNC_ALGOS
 	// example for choosing different algos for point and spot lights
 	return EvalShadow_PunctualDepth( shadowContext, algo, tex, compSamp, positionWS, normalWS, shadowDataIndex, L );
 #endif
 }
-float GetPunctualShadowAttenuation( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float3 L, float2 unPositionSS )
+float GetPunctualShadowAttenuation( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float4 L, float2 unPositionSS )
 {
 	return GetPunctualShadowAttenuation( shadowContext, positionWS, normalWS, shadowDataIndex, L );
 }

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

             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;
         public class TileSettings
         {
             public bool enableTileAndCluster; // For debug / test
-            public bool enableSplitLightEvaluation;
             public bool enableComputeLightEvaluation;
             public bool enableComputeLightVariants;
             public bool enableComputeMaterialVariants;
                 None = 0, Punctual = 1, Area = 2, AreaAndPunctual = 3, Environment = 4, EnvironmentAndPunctual = 5, EnvironmentAndArea = 6, EnvironmentAndAreaAndPunctual = 7,
                 FeatureVariants = 8
             }; //TODO: we should probably make this checkboxes
-            public TileDebug tileDebugByCategory;
-                enableSplitLightEvaluation = true;
                 enableComputeLightEvaluation = true;
                 enableComputeLightVariants = true;
                 enableComputeMaterialVariants = true;
 
                 diffuseGlobalDimmer = 1.0f;
                 specularGlobalDimmer = 1.0f;
-
-                tileDebugByCategory = TileDebug.None;
             }
         }
 
             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;
                 }
             }
 
-            Material m_DeferredDirectMaterialSRT   = null;
-            Material m_DeferredDirectMaterialMRT   = null;
-            Material m_DeferredIndirectMaterialSRT = null;
-            Material m_DeferredIndirectMaterialMRT = null;
             Material m_DeferredAllMaterialSRT      = null;
             Material m_DeferredAllMaterialMRT      = null;
 
                 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);
+                    s_shadeOpaqueIndirectClusteredKernels[variant] = deferredComputeShader.FindKernel("Deferred_Indirect_Clustered_Variant" + variant);
+                    s_shadeOpaqueIndirectFptlKernels[variant] = deferredComputeShader.FindKernel("Deferred_Indirect_Fptl_Variant" + variant);
                 }
 
                 s_LightList = null;
-                string[] tileKeywords = {"LIGHTLOOP_TILE_DIRECT", "LIGHTLOOP_TILE_INDIRECT", "LIGHTLOOP_TILE_ALL"};
-
-                m_DeferredDirectMaterialSRT = Utilities.CreateEngineMaterial(m_Resources.deferredShader);
-                Utilities.SelectKeyword(m_DeferredDirectMaterialSRT, tileKeywords, 0);
-                m_DeferredDirectMaterialSRT.EnableKeyword("LIGHTLOOP_TILE_PASS");
-                m_DeferredDirectMaterialSRT.DisableKeyword("OUTPUT_SPLIT_LIGHTING");
-                m_DeferredDirectMaterialSRT.SetInt("_StencilRef", (int)StencilLightingUsage.RegularLighting);
-                m_DeferredDirectMaterialSRT.SetInt("_StencilCmp", (int)CompareFunction.Equal);
-                m_DeferredDirectMaterialSRT.SetInt("_SrcBlend", (int)BlendMode.One);
-                m_DeferredDirectMaterialSRT.SetInt("_DstBlend", (int)BlendMode.Zero);
-
-                m_DeferredDirectMaterialMRT = Utilities.CreateEngineMaterial(m_Resources.deferredShader);
-                Utilities.SelectKeyword(m_DeferredDirectMaterialMRT, tileKeywords, 0);
-                m_DeferredDirectMaterialMRT.EnableKeyword("LIGHTLOOP_TILE_PASS");
-                m_DeferredDirectMaterialMRT.EnableKeyword("OUTPUT_SPLIT_LIGHTING");
-                m_DeferredDirectMaterialMRT.SetInt("_StencilRef", (int)StencilLightingUsage.SplitLighting);
-                m_DeferredDirectMaterialMRT.SetInt("_StencilCmp", (int)CompareFunction.Equal);
-                m_DeferredDirectMaterialMRT.SetInt("_SrcBlend", (int)BlendMode.One);
-                m_DeferredDirectMaterialMRT.SetInt("_DstBlend", (int)BlendMode.Zero);
-
-                m_DeferredIndirectMaterialSRT = Utilities.CreateEngineMaterial(m_Resources.deferredShader);
-                Utilities.SelectKeyword(m_DeferredIndirectMaterialSRT, tileKeywords, 1);
-                m_DeferredIndirectMaterialSRT.EnableKeyword("LIGHTLOOP_TILE_PASS");
-                m_DeferredIndirectMaterialSRT.DisableKeyword("OUTPUT_SPLIT_LIGHTING");
-                m_DeferredIndirectMaterialSRT.SetInt("_StencilRef", (int)StencilLightingUsage.RegularLighting);
-                m_DeferredIndirectMaterialSRT.SetInt("_StencilCmp", (int)CompareFunction.Equal);
-                m_DeferredIndirectMaterialSRT.SetInt("_SrcBlend", (int)BlendMode.One);
-                m_DeferredIndirectMaterialSRT.SetInt("_DstBlend", (int)BlendMode.One); // Additive color & alpha source
-
-                m_DeferredIndirectMaterialMRT = Utilities.CreateEngineMaterial(m_Resources.deferredShader);
-                Utilities.SelectKeyword(m_DeferredIndirectMaterialMRT, tileKeywords, 1);
-                m_DeferredIndirectMaterialMRT.EnableKeyword("LIGHTLOOP_TILE_PASS");
-                m_DeferredIndirectMaterialMRT.EnableKeyword("OUTPUT_SPLIT_LIGHTING");
-                m_DeferredIndirectMaterialMRT.SetInt("_StencilRef", (int)StencilLightingUsage.SplitLighting);
-                m_DeferredIndirectMaterialMRT.SetInt("_StencilCmp", (int)CompareFunction.Equal);
-                m_DeferredIndirectMaterialMRT.SetInt("_SrcBlend", (int)BlendMode.One);
-                m_DeferredIndirectMaterialMRT.SetInt("_DstBlend", (int)BlendMode.One); // Additive color & alpha source
-
-                Utilities.SelectKeyword(m_DeferredAllMaterialSRT, tileKeywords, 2);
                 m_DeferredAllMaterialSRT.EnableKeyword("LIGHTLOOP_TILE_PASS");
                 m_DeferredAllMaterialSRT.DisableKeyword("OUTPUT_SPLIT_LIGHTING");
                 m_DeferredAllMaterialSRT.SetInt("_StencilRef", (int)StencilLightingUsage.RegularLighting);
 
                 m_DeferredAllMaterialMRT = Utilities.CreateEngineMaterial(m_Resources.deferredShader);
-                Utilities.SelectKeyword(m_DeferredAllMaterialMRT, tileKeywords, 2);
                 m_DeferredAllMaterialMRT.EnableKeyword("LIGHTLOOP_TILE_PASS");
                 m_DeferredAllMaterialMRT.EnableKeyword("OUTPUT_SPLIT_LIGHTING");
                 m_DeferredAllMaterialMRT.SetInt("_StencilRef", (int)StencilLightingUsage.SplitLighting);
                 // enableClustered
                 Utilities.SafeRelease(s_GlobalLightListAtomic);
 
-                Utilities.Destroy(m_DeferredDirectMaterialSRT);
-                Utilities.Destroy(m_DeferredDirectMaterialMRT);
-                Utilities.Destroy(m_DeferredIndirectMaterialSRT);
-                Utilities.Destroy(m_DeferredIndirectMaterialMRT);
                 Utilities.Destroy(m_DeferredAllMaterialSRT);
                 Utilities.Destroy(m_DeferredAllMaterialMRT);
 
 
             private void SetupDebugDisplayMode(bool debugDisplayEnable)
             {
-                Utilities.SetKeyword(m_DeferredDirectMaterialSRT, "DEBUG_DISPLAY", debugDisplayEnable);
-                Utilities.SetKeyword(m_DeferredDirectMaterialMRT, "DEBUG_DISPLAY", debugDisplayEnable);
-                Utilities.SetKeyword(m_DeferredIndirectMaterialSRT, "DEBUG_DISPLAY", debugDisplayEnable);
-                Utilities.SetKeyword(m_DeferredIndirectMaterialMRT, "DEBUG_DISPLAY", debugDisplayEnable);
                 Utilities.SetKeyword(m_DeferredAllMaterialSRT, "DEBUG_DISPLAY", debugDisplayEnable);
                 Utilities.SetKeyword(m_DeferredAllMaterialMRT, "DEBUG_DISPLAY", debugDisplayEnable);
                 Utilities.SetKeyword(m_SingleDeferredMaterialSRT, "DEBUG_DISPLAY", debugDisplayEnable);
-            public void RenderLightingDebug(HDCamera hdCamera, CommandBuffer cmd, RenderTargetIdentifier colorBuffer)
+            public void RenderLightingDebug(HDCamera hdCamera, CommandBuffer cmd, RenderTargetIdentifier colorBuffer, DebugDisplaySettings debugDisplaySettings)
-                if (m_TileSettings.tileDebugByCategory == TileSettings.TileDebug.None)
+                LightingDebugSettings lightingDebug = debugDisplaySettings.lightingDebugSettings;
+                if (lightingDebug.tileDebugByCategory == TileSettings.TileDebug.None)
                     return;
 
                 using (new Utilities.ProfilingSample("Tiled Lighting Debug", cmd))
 
                     // Debug tiles
                     PushGlobalParams(hdCamera.camera, cmd, null, 0);
-                    if (m_TileSettings.tileDebugByCategory == TileSettings.TileDebug.FeatureVariants)
+                    if (lightingDebug.tileDebugByCategory == TileSettings.TileDebug.FeatureVariants)
-                            m_DebugViewTilesMaterial.SetInt("_ViewTilesFlags", (int)m_TileSettings.tileDebugByCategory);
+                            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);
                             cmd.DrawProcedural(Matrix4x4.identity, m_DebugViewTilesMaterial, 0, MeshTopology.Triangles, numTiles * 6);
                         }
                     }
-                    else if (m_TileSettings.tileDebugByCategory != TileSettings.TileDebug.None)
+                    else if (lightingDebug.tileDebugByCategory != TileSettings.TileDebug.None)
-                        m_DebugViewTilesMaterial.SetInt("_ViewTilesFlags", (int)m_TileSettings.tileDebugByCategory);
+                        m_DebugViewTilesMaterial.SetInt("_ViewTilesFlags", (int)lightingDebug.tileDebugByCategory);
                         m_DebugViewTilesMaterial.SetVector("_MousePixelCoord", mousePixelCoord);
                         m_DebugViewTilesMaterial.EnableKeyword(bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
                         m_DebugViewTilesMaterial.DisableKeyword(!bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
             {
                 var bUseClusteredForDeferred = !usingFptl;
 
-                if (m_TileSettings.enableComputeLightEvaluation && outputSplitLighting)
+                if (m_TileSettings.enableTileAndCluster && m_TileSettings.enableComputeLightEvaluation && outputSplitLighting)
                 {
                     // The CS is always in the MRT mode. Do not execute the same shader twice.
                     return;
                             Vector4 zbufferParams = Shader.GetGlobalVector("_ZBufferParams");
                             Vector4 unity_OrthoParams = Shader.GetGlobalVector("unity_OrthoParams");
                             int envLightSkyEnabled = Shader.GetGlobalInt("_EnvLightSkyEnabled");
+                            float ambientOcclusionDirectLightStrenght = Shader.GetGlobalFloat("_AmbientOcclusionDirectLightStrenght");
 
                             int enableSSSAndTransmission = Shader.GetGlobalInt("_EnableSSSAndTransmission");
                             int texturingModeFlags = Shader.GetGlobalInt("_TexturingModeFlags");
 
                                 // 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, "_DebugViewMaterial", debugViewMaterial);
+                                cmd.SetComputeIntParam(deferredComputeShader, "_DebugLightingMode", debugLightingMode);
+                                cmd.SetComputeVectorParam(deferredComputeShader, "_DebugLightingAlbedo", debugLightingAlbedo);
+                                cmd.SetComputeVectorParam(deferredComputeShader, "_DebugLightingSmoothness", debugLightingSmoothness);
-                                cmd.SetComputeBufferParam(shadeOpaqueShader, kernel, "g_vLightListGlobal", bUseClusteredForDeferred ? s_PerVoxelLightLists : s_LightList);
+                                cmd.SetComputeBufferParam(deferredComputeShader, kernel, "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, "_MainDepthTexture", depthTexture);
+                                cmd.SetComputeTextureParam(deferredComputeShader, kernel, "_GBufferTexture0", gbufferTexture0);
+                                cmd.SetComputeTextureParam(deferredComputeShader, kernel, "_GBufferTexture1", gbufferTexture1);
+                                cmd.SetComputeTextureParam(deferredComputeShader, kernel, "_GBufferTexture2", gbufferTexture2);
+                                cmd.SetComputeTextureParam(deferredComputeShader, kernel, "_GBufferTexture3", gbufferTexture3);
+                                cmd.SetComputeTextureParam(deferredComputeShader, kernel, "_AmbientOcclusionTexture", 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, "_LtcData", ltcData);
+                                cmd.SetComputeTextureParam(deferredComputeShader, kernel, "_PreIntegratedFGD", preIntegratedFGD);
+                                cmd.SetComputeTextureParam(deferredComputeShader, kernel, "_LtcGGXMatrix", ltcGGXMatrix);
+                                cmd.SetComputeTextureParam(deferredComputeShader, kernel, "_LtcDisneyDiffuseMatrix", ltcDisneyDiffuseMatrix);
+                                cmd.SetComputeTextureParam(deferredComputeShader, kernel, "_LtcMultiGGXFresnelDisneyDiffuse", ltcMultiGGXFresnelDisneyDiffuse);
-                                cmd.SetComputeMatrixParam(shadeOpaqueShader, "g_mInvScrProjection", invScrProjection);
-                                cmd.SetComputeIntParam(shadeOpaqueShader, "_UseTileLightList", useTileLightList);
+                                cmd.SetComputeMatrixParam(deferredComputeShader, "g_mInvScrProjection", invScrProjection);
+                                cmd.SetComputeIntParam(deferredComputeShader, "_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.SetComputeIntParam(shadeOpaqueShader, "_EnvLightSkyEnabled", envLightSkyEnabled);
+                                cmd.SetComputeVectorParam(deferredComputeShader, "_Time", time);
+                                cmd.SetComputeVectorParam(deferredComputeShader, "_SinTime", sinTime);
+                                cmd.SetComputeVectorParam(deferredComputeShader, "_CosTime", cosTime);
+                                cmd.SetComputeVectorParam(deferredComputeShader, "unity_DeltaTime", unity_DeltaTime);
+                                cmd.SetComputeIntParam(deferredComputeShader, "_EnvLightSkyEnabled", envLightSkyEnabled);
+                                cmd.SetComputeFloatParam(deferredComputeShader, "_AmbientOcclusionDirectLightStrenght", ambientOcclusionDirectLightStrenght);
-                                cmd.SetComputeTextureParam(shadeOpaqueShader, kernel, "_IESArray", IESArrayTexture ? IESArrayTexture : m_DefaultTexture2DArray);
-                                cmd.SetComputeTextureParam(shadeOpaqueShader, kernel, "_SkyTexture", skyTexture ? skyTexture : m_DefaultTexture2DArray);
+                                cmd.SetComputeTextureParam(deferredComputeShader, kernel, "_IESArray", IESArrayTexture ? IESArrayTexture : m_DefaultTexture2DArray);
+                                cmd.SetComputeTextureParam(deferredComputeShader, kernel, "_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, "_EnableSSSAndTransmission", enableSSSAndTransmission);
+                                cmd.SetComputeIntParam(   deferredComputeShader, "_TexturingModeFlags",       texturingModeFlags);
+                                cmd.SetComputeIntParam(   deferredComputeShader, "_TransmissionFlags",        transmissionFlags);
+                                cmd.SetComputeVectorArrayParam(deferredComputeShader, "_ThicknessRemaps",     thicknessRemaps);
-                                cmd.SetComputeVectorArrayParam(shadeOpaqueShader, "_ShapeParams",       shapeParams);
-                                cmd.SetComputeVectorArrayParam(shadeOpaqueShader, "_TransmissionTints", transmissionTints);
+                                cmd.SetComputeVectorArrayParam(deferredComputeShader, "_ShapeParams",       shapeParams);
+                                cmd.SetComputeVectorArrayParam(deferredComputeShader, "_TransmissionTints", transmissionTints);
-                                cmd.SetComputeTextureParam(shadeOpaqueShader, kernel, "specularLightingUAV", colorBuffers[0]);
-                                cmd.SetComputeTextureParam(shadeOpaqueShader, kernel, "diffuseLightingUAV",  colorBuffers[1]);
+                                cmd.SetComputeTextureParam(deferredComputeShader, kernel, "specularLightingUAV", colorBuffers[0]);
+                                cmd.SetComputeTextureParam(deferredComputeShader, kernel, "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, "g_TileListOffset", variant * numTiles);
+                                    cmd.SetComputeBufferParam(deferredComputeShader, kernel, "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);
                                 }
                             }
                         }
                             PushGlobalParams(camera, cmd, null, 0);
 
-                            if (m_TileSettings.enableSplitLightEvaluation)
+                            if (outputSplitLighting)
-                                if (outputSplitLighting)
-                                {
-                                    Utilities.SelectKeyword(m_DeferredDirectMaterialMRT, "USE_CLUSTERED_LIGHTLIST", "USE_FPTL_LIGHTLIST", bUseClusteredForDeferred);
-                                    Utilities.DrawFullScreen(cmd, m_DeferredDirectMaterialMRT, colorBuffers, depthStencilBuffer);
-
-                                    Utilities.SelectKeyword(m_DeferredIndirectMaterialMRT, "USE_CLUSTERED_LIGHTLIST", "USE_FPTL_LIGHTLIST", bUseClusteredForDeferred);
-                                    Utilities.DrawFullScreen(cmd, m_DeferredIndirectMaterialMRT, colorBuffers, depthStencilBuffer);
-                                }
-                                else
-                                {
-                                    // If SSS is disable, do lighting for both split lighting and no split lighting
-                                    if (!debugDisplaySettings.renderingDebugSettings.enableSSSAndTransmission)
-                                    {
-                                        m_DeferredDirectMaterialSRT.SetInt("_StencilRef", (int)StencilLightingUsage.NoLighting);
-                                        m_DeferredDirectMaterialSRT.SetInt("_StencilCmp", (int)CompareFunction.NotEqual);
-
-                                        m_DeferredIndirectMaterialSRT.SetInt("_StencilRef", (int)StencilLightingUsage.NoLighting);
-                                        m_DeferredIndirectMaterialSRT.SetInt("_StencilCmp", (int)CompareFunction.NotEqual);
-                                    }
-                                    else
-                                    {
-                                        m_DeferredDirectMaterialSRT.SetInt("_StencilRef", (int)StencilLightingUsage.RegularLighting);
-                                        m_DeferredDirectMaterialSRT.SetInt("_StencilCmp", (int)CompareFunction.Equal);
-
-                                        m_DeferredIndirectMaterialSRT.SetInt("_StencilRef", (int)StencilLightingUsage.RegularLighting);
-                                        m_DeferredIndirectMaterialSRT.SetInt("_StencilCmp", (int)CompareFunction.Equal);
-                                    }
-
-                                    Utilities.SelectKeyword(m_DeferredDirectMaterialSRT, "USE_CLUSTERED_LIGHTLIST", "USE_FPTL_LIGHTLIST", bUseClusteredForDeferred);
-                                    Utilities.DrawFullScreen(cmd, m_DeferredDirectMaterialSRT, colorBuffers[0], depthStencilBuffer);
-
-                                    Utilities.SelectKeyword(m_DeferredIndirectMaterialSRT, "USE_CLUSTERED_LIGHTLIST", "USE_FPTL_LIGHTLIST", bUseClusteredForDeferred);
-                                    Utilities.DrawFullScreen(cmd, m_DeferredIndirectMaterialSRT, colorBuffers[0], depthStencilBuffer);
-                                }
+                                Utilities.SelectKeyword(m_DeferredAllMaterialMRT, "USE_CLUSTERED_LIGHTLIST", "USE_FPTL_LIGHTLIST", bUseClusteredForDeferred);
+                                Utilities.DrawFullScreen(cmd, m_DeferredAllMaterialMRT, colorBuffers, depthStencilBuffer);
-                                if (outputSplitLighting)
+                                // If SSS is disable, do lighting for both split lighting and no split lighting
+                                if (!debugDisplaySettings.renderingDebugSettings.enableSSSAndTransmission)
-                                    Utilities.SelectKeyword(m_DeferredAllMaterialMRT, "USE_CLUSTERED_LIGHTLIST", "USE_FPTL_LIGHTLIST", bUseClusteredForDeferred);
-                                    Utilities.DrawFullScreen(cmd, m_DeferredAllMaterialMRT, colorBuffers, depthStencilBuffer);
+                                    m_DeferredAllMaterialSRT.SetInt("_StencilRef", (int)StencilLightingUsage.NoLighting);
+                                    m_DeferredAllMaterialSRT.SetInt("_StencilCmp", (int)CompareFunction.NotEqual);
-                                    // 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);
-                                    }
-                                    else
-                                    {
-                                        m_DeferredAllMaterialSRT.SetInt("_StencilRef", (int)StencilLightingUsage.RegularLighting);
-                                        m_DeferredAllMaterialSRT.SetInt("_StencilCmp", (int)CompareFunction.Equal);
-                                    }
-
-                                    Utilities.SelectKeyword(m_DeferredAllMaterialSRT, "USE_CLUSTERED_LIGHTLIST", "USE_FPTL_LIGHTLIST", bUseClusteredForDeferred);
-                                    Utilities.DrawFullScreen(cmd, m_DeferredAllMaterialSRT, colorBuffers[0], depthStencilBuffer);
+                                    m_DeferredAllMaterialSRT.SetInt("_StencilRef", (int)StencilLightingUsage.RegularLighting);
+                                    m_DeferredAllMaterialSRT.SetInt("_StencilCmp", (int)CompareFunction.Equal);
+
+                                Utilities.SelectKeyword(m_DeferredAllMaterialSRT, "USE_CLUSTERED_LIGHTLIST", "USE_FPTL_LIGHTLIST", bUseClusteredForDeferred);
+                                Utilities.DrawFullScreen(cmd, m_DeferredAllMaterialSRT, colorBuffers[0], depthStencilBuffer);
                             }
                         }
                     }

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
 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
         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;
-            diffuseLighting += localDiffuseLighting;
-            specularLighting += localSpecularLighting;
+            while (i < areaLightCount && lightType == GPULIGHTTYPE_LINE)
+            {
+                EvaluateBSDF_Area(  context, V, posInput, prelightData, _LightDatas[areaIndex], bsdfData, GPULIGHTTYPE_LINE,
+                                    localDiffuseLighting, localSpecularLighting);
-            i++;
+                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;
+
+                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
-#endif
-#ifdef PROCESS_ENV_LIGHT
+    // 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.
     // Only apply sky IBL if the sky texture is available.
     if(featureFlags & LIGHTFEATUREFLAGS_SKY)
     {
         }
     }
 
-
+        #ifdef LIGHTLOOP_TILE_PASS
+
         uint envLightStart;
         uint envLightCount;
         GetCountAndStart(posInput, LIGHTCATEGORY_ENV, envLightStart, envLightCount);
             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);
         }
-    }
-
-    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)
-    {
-        float3 localDiffuseLighting, localSpecularLighting;
+        #else
-        if (_LightDatas[i].lightType == GPULIGHTTYPE_LINE)
-        {
-            EvaluateBSDF_Line(  context, V, posInput, prelightData, _LightDatas[i], bsdfData,
-                                localDiffuseLighting, localSpecularLighting);
-        }
-        else
+        for (i = 0; i < _EnvLightCount; ++i)
-            EvaluateBSDF_Area(  context, V, posInput, prelightData, _LightDatas[i], bsdfData,
-                                localDiffuseLighting, localSpecularLighting);
+            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);
-        diffuseLighting += localDiffuseLighting;
-        specularLighting += localSpecularLighting;
-    }
-
-    // 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);
-
-    // 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);
+        #endif
-    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/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

     /* 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)
                             (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
 
     float3 cookie    = float3(1, 1, 1);
     float  shadow    = 1;
 
-    // TODO: measure impact of having all these dynamic branch here and the gain (or not) of testing illuminace > 0
-
-    //[branch] if (lightData.IESIndex >= 0 && illuminance > 0.0)
-    //{
-    //    float3x3 lightToWorld = float3x3(lightData.right, lightData.up, lightData.forward);
-    //    float2 sphericalCoord = GetIESTextureCoordinate(lightToWorld, L);
-    //    illuminance *= SampleIES(lightLoopContext, lightData.IESIndex, sphericalCoord, 0).r;
-    //}
-
-        shadow = GetPunctualShadowAttenuation(lightLoopContext.shadowContext, positionWS + offset, bsdfData.normalWS, lightData.shadowIndex, L, posInput.unPositionSS);
+        float4 L_dist = { normalize( L.xyz ), length( unL ) };
+        shadow = GetPunctualShadowAttenuation(lightLoopContext.shadowContext, positionWS + offset, bsdfData.normalWS, lightData.shadowIndex, L_dist, posInput.unPositionSS);
         shadow = lerp(1.0, shadow, lightData.shadowDimmer);
 
         illuminance *= shadow;
     }
 }
 
-//-----------------------------------------------------------------------------
-// EvaluateBSDF_Line - Reference
-//-----------------------------------------------------------------------------
-
-void IntegrateBSDF_LineRef(float3 V, float3 positionWS,
-                           PreLightData preLightData, LightData lightData, BSDFData bsdfData,
-                           out float3 diffuseLighting, out float3 specularLighting,
-                           int sampleCount = 128)
-{
-    diffuseLighting  = float3(0.0, 0.0, 0.0);
-    specularLighting = float3(0.0, 0.0, 0.0);
-
-    const float  len = lightData.size.x;
-    const float3 T   = lightData.right;
-    const float3 P1  = lightData.positionWS - T * (0.5 * len);
-    const float  dt  = len * rcp(sampleCount);
-    const float  off = 0.5 * dt;
-
-    // Uniformly sample the line segment with the Pdf = 1 / len.
-    const float invPdf = len;
-
-    for (int i = 0; i < sampleCount; ++i)
-    {
-        // Place the sample in the middle of the interval.
-        float  t     = off + i * dt;
-        float3 sPos  = P1 + t * T;
-        float3 unL   = sPos - positionWS;
-        float  dist2 = dot(unL, unL);
-        float3 L     = normalize(unL);
-        float  sinLT = length(cross(L, T));
-        float  NdotL = saturate(dot(bsdfData.normalWS, L));
-
-        if (NdotL > 0)
-        {
-            float3 lightDiff, lightSpec;
-
-            BSDF(V, L, positionWS, preLightData, bsdfData, lightDiff, lightSpec);
-
-            diffuseLighting  += lightDiff * (sinLT / dist2 * NdotL);
-            specularLighting += lightSpec * (sinLT / dist2 * NdotL);
-        }
-    }
-
-    // The factor of 2 is due to the fact: Integral{0, 2 PI}{max(0, cos(x))dx} = 2.
-    float normFactor = 2.0 * invPdf * rcp(sampleCount);
-
-    diffuseLighting  *= normFactor * lightData.diffuseScale  * lightData.color;
-    specularLighting *= normFactor * lightData.specularScale * lightData.color;
-}
+#include "LitReference.hlsl"
 
 //-----------------------------------------------------------------------------
 // EvaluateBSDF_Line - Approximation with Linearly Transformed Cosines
 }
 
 //-----------------------------------------------------------------------------
-// EvaluateBSDF_Area - Reference
-//-----------------------------------------------------------------------------
-
-void IntegrateBSDF_AreaRef(float3 V, float3 positionWS,
-                           PreLightData preLightData, LightData lightData, BSDFData bsdfData,
-                           out float3 diffuseLighting, out float3 specularLighting,
-                           uint sampleCount = 512)
-{
-    // Add some jittering on Hammersley2d
-    float2 randNum = InitRandom(V.xy * 0.5 + 0.5);
-
-    diffuseLighting = float3(0.0, 0.0, 0.0);
-    specularLighting = float3(0.0, 0.0, 0.0);
-
-    for (uint i = 0; i < sampleCount; ++i)
-    {
-        float3 P = float3(0.0, 0.0, 0.0);   // Sample light point. Random point on the light shape in local space.
-        float3 Ns = float3(0.0, 0.0, 0.0);  // Unit surface normal at P
-        float lightPdf = 0.0;               // Pdf of the light sample
-
-        float2 u = Hammersley2d(i, sampleCount);
-        u = frac(u + randNum);
-
-        // Lights in Unity point backward.
-        float4x4 localToWorld = float4x4(float4(lightData.right, 0.0), float4(lightData.up, 0.0), float4(-lightData.forward, 0.0), float4(lightData.positionWS, 1.0));
-
-        switch (lightData.lightType)
-        {
-            case GPULIGHTTYPE_SPHERE:
-                SampleSphere(u, localToWorld, lightData.size.x, lightPdf, P, Ns);
-                break;
-            case GPULIGHTTYPE_HEMISPHERE:
-                SampleHemisphere(u, localToWorld, lightData.size.x, lightPdf, P, Ns);
-                break;
-            case GPULIGHTTYPE_CYLINDER:
-                SampleCylinder(u, localToWorld, lightData.size.x, lightData.size.y, lightPdf, P, Ns);
-                break;
-            case GPULIGHTTYPE_RECTANGLE:
-                SampleRectangle(u, localToWorld, lightData.size.x, lightData.size.y, lightPdf, P, Ns);
-                break;
-            case GPULIGHTTYPE_DISK:
-                SampleDisk(u, localToWorld, lightData.size.x, lightPdf, P, Ns);
-                break;
-            // case GPULIGHTTYPE_LINE: handled by a separate function.
-        }
-
-        // Get distance
-        float3 unL = P - positionWS;
-        float sqrDist = dot(unL, unL);
-        float3 L = normalize(unL);
-
-        // Cosine of the angle between the light direction and the normal of the light's surface.
-        float cosLNs = saturate(dot(-L, Ns));
-
-        // We calculate area reference light with the area integral rather than the solid angle one.
-        float illuminance = cosLNs * saturate(dot(bsdfData.normalWS, L)) / (sqrDist * lightPdf);
-
-        float3 localDiffuseLighting = float3(0.0, 0.0, 0.0);
-        float3 localSpecularLighting = float3(0.0, 0.0, 0.0);
-
-        if (illuminance > 0.0)
-        {
-            BSDF(V, L, positionWS, preLightData, bsdfData, localDiffuseLighting, localSpecularLighting);
-            localDiffuseLighting *= lightData.color * illuminance * lightData.diffuseScale;
-            localSpecularLighting *= lightData.color * illuminance * lightData.specularScale;
-        }
-
-        diffuseLighting += localDiffuseLighting;
-        specularLighting += localSpecularLighting;
-    }
-
-    diffuseLighting /= float(sampleCount);
-    specularLighting /= float(sampleCount);
-}
-
-//-----------------------------------------------------------------------------
-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;
 
 #endif // LIT_DISPLAY_REFERENCE_AREA
 }
 
-//-----------------------------------------------------------------------------
-// EvaluateBSDF_Env - Reference
-// ----------------------------------------------------------------------------
-
-// Ref: Moving Frostbite to PBR (Appendix A)
-float3 IntegrateLambertIBLRef(LightLoopContext lightLoopContext,
-                              float3 V, EnvLightData lightData, BSDFData bsdfData,
-                              uint sampleCount = 4096)
+void EvaluateBSDF_Area(LightLoopContext lightLoopContext,
+    float3 V, PositionInputs posInput,
+    PreLightData preLightData, LightData lightData, BSDFData bsdfData, int GPULightType,
+    out float3 diffuseLighting, out float3 specularLighting)
-    float3x3 localToWorld = float3x3(bsdfData.tangentWS, bsdfData.bitangentWS, bsdfData.normalWS);
-    float3   acc          = float3(0.0, 0.0, 0.0);
-
-    // Add some jittering on Hammersley2d
-    float2 randNum  = InitRandom(V.xy * 0.5 + 0.5);
-
-    for (uint i = 0; i < sampleCount; ++i)
+    if (GPULightType == GPULIGHTTYPE_LINE)
-        float2 u    = Hammersley2d(i, sampleCount);
-        u           = frac(u + randNum);
-
-        float3 L;
-        float NdotL;
-        float weightOverPdf;
-        ImportanceSampleLambert(u, localToWorld, L, NdotL, weightOverPdf);
-
-        if (NdotL > 0.0)
-        {
-            float4 val = SampleEnv(lightLoopContext, lightData.envIndex, L, 0);
-
-            // diffuse Albedo is apply here as describe in ImportanceSampleLambert function
-            acc += bsdfData.diffuseColor * LambertNoPI() * weightOverPdf * val.rgb;
-        }
+        EvaluateBSDF_Line(lightLoopContext, V, posInput, preLightData, lightData, bsdfData, diffuseLighting, specularLighting);
-
-    return acc / sampleCount;
-}
-
-float3 IntegrateDisneyDiffuseIBLRef(LightLoopContext lightLoopContext,
-                                    float3 V, PreLightData preLightData, EnvLightData lightData, BSDFData bsdfData,
-                                    uint sampleCount = 4096)
-{
-    float3x3 localToWorld = float3x3(bsdfData.tangentWS, bsdfData.bitangentWS, bsdfData.normalWS);
-    float    NdotV        = max(preLightData.NdotV, MIN_N_DOT_V);
-    float3   acc          = float3(0.0, 0.0, 0.0);
-
-    // Add some jittering on Hammersley2d
-    float2 randNum  = InitRandom(V.xy * 0.5 + 0.5);
-
-    for (uint i = 0; i < sampleCount; ++i)
+    else
-        float2 u    = Hammersley2d(i, sampleCount);
-        u           = frac(u + randNum);
-
-        float3 L;
-        float NdotL;
-        float weightOverPdf;
-        // for Disney we still use a Cosine importance sampling, true Disney importance sampling imply a look up table
-        ImportanceSampleLambert(u, localToWorld, L, NdotL, weightOverPdf);
-
-        if (NdotL > 0.0)
-        {
-            float3 H = normalize(L + V);
-            float LdotH = dot(L, H);
-            // Note: we call DisneyDiffuse that require to multiply by Albedo / PI. Divide by PI is already taken into account
-            // in weightOverPdf of ImportanceSampleLambert call.
-            float disneyDiffuse = DisneyDiffuse(NdotV, NdotL, LdotH, bsdfData.perceptualRoughness);
-
-            // diffuse Albedo is apply here as describe in ImportanceSampleLambert function
-            float4 val = SampleEnv(lightLoopContext, lightData.envIndex, L, 0);
-            acc += bsdfData.diffuseColor * disneyDiffuse * weightOverPdf * val.rgb;
-        }
+        EvaluateBSDF_Rect(lightLoopContext, V, posInput, preLightData, lightData, bsdfData, diffuseLighting, specularLighting);
-
-    return acc / sampleCount;
-}
-
-// Ref: Moving Frostbite to PBR (Appendix A)
-float3 IntegrateSpecularGGXIBLRef(LightLoopContext lightLoopContext,
-                                  float3 V, PreLightData preLightData, EnvLightData lightData, BSDFData bsdfData,
-                                  uint sampleCount = 4096)
-{
-    float3x3 localToWorld = float3x3(bsdfData.tangentWS, bsdfData.bitangentWS, bsdfData.normalWS);
-    float    NdotV        = max(preLightData.NdotV, MIN_N_DOT_V);
-    float3   acc          = float3(0.0, 0.0, 0.0);
-
-    // Add some jittering on Hammersley2d
-    float2 randNum  = InitRandom(V.xy * 0.5 + 0.5);
-
-    for (uint i = 0; i < sampleCount; ++i)
-    {
-        float2 u    = Hammersley2d(i, sampleCount);
-        u           = frac(u + randNum);
-
-        float VdotH;
-        float NdotL;
-        float3 L;
-        float weightOverPdf;
-
-        // GGX BRDF
-        if (bsdfData.materialId == MATERIALID_LIT_ANISO)
-        {
-            ImportanceSampleAnisoGGX(u, V, localToWorld, bsdfData.roughnessT, bsdfData.roughnessB, NdotV, L, VdotH, NdotL, weightOverPdf);
-        }
-        else
-        {
-            ImportanceSampleGGX(u, V, localToWorld, bsdfData.roughness, NdotV, L, VdotH, NdotL, weightOverPdf);
-        }
-
-
-        if (NdotL > 0.0)
-        {
-            // Fresnel component is apply here as describe in ImportanceSampleGGX function
-            float3 FweightOverPdf = F_Schlick(bsdfData.fresnel0, VdotH) * weightOverPdf;
-
-            float4 val = SampleEnv(lightLoopContext, lightData.envIndex, L, 0);
-
-            acc += FweightOverPdf * val.rgb;
-        }
-    }
-
-    return acc / sampleCount;
 }
 
 //-----------------------------------------------------------------------------

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/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

             #pragma fragment Frag
 
             #include "../../../../ShaderLibrary/Common.hlsl"
-            #include "../../../ShaderConfig.cs.hlsl"
             #include "../../../ShaderVariables.hlsl"
             #include "../../../Lighting/LightDefinition.cs.hlsl"
 

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

 
 #include "../../../../ShaderLibrary/Common.hlsl"
 #include "../../../../ShaderLibrary/SpaceFillingCurves.hlsl"
-#include "../../../ShaderConfig.cs.hlsl"
 #include "../../../ShaderVariables.hlsl"
 #define UNITY_MATERIAL_LIT
 #include "../../../Material/Material.hlsl"

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

             //-------------------------------------------------------------------------------------
 
             #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"

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 "../ShaderPass/VaryingMesh.hlsl"
         #include "../ShaderPass/VertMesh.hlsl"
 
+        float4 _CameraPosDiff;
+
         struct Attributes
         {
             uint vertexID : SV_VertexID;
             float depth = LOAD_TEXTURE2D(_MainDepthTexture, posInput.unPositionSS).x;
             UpdatePositionInput(depth, _InvViewProjMatrix, _ViewProjMatrix, posInput);
             float4 worldPos = float4(posInput.positionWS, 1.0);
+            float4 prevPos = worldPos;
-            float4 prevClipPos = mul(_PrevViewProjMatrix, worldPos);
+        #if (SHADEROPTIONS_CAMERA_RELATIVE_RENDERING != 0)
+            prevPos -= _CameraPosDiff;
+        #endif
+
+            float4 prevClipPos = mul(_PrevViewProjMatrix, prevPos);
             float4 curClipPos = mul(_NonJitteredViewProjMatrix, worldPos);
             float2 prevHPos = prevClipPos.xy / prevClipPos.w;
             float2 curHPos = curClipPos.xy / curClipPos.w;
+
+        #if UNITY_UV_STARTS_AT_TOP
+            previousPositionCS.y = 1.0 - previousPositionCS.y;
+            positionCS.y = 1.0 - positionCS.y;
+        #endif
 
             return float4(positionCS - previousPositionCS, 0.0, 1.0);
         }

Assets/ScriptableRenderPipeline/HDRenderPipeline/RenderPipelineResources/HDRenderPipelineResources.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,

Assets/ScriptableRenderPipeline/HDRenderPipeline/RenderPipelineResources/RenderPipelineResources.cs

             instance.buildPerBigTileLightListShader = UnityEditor.AssetDatabase.LoadAssetAtPath<ComputeShader>("Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/lightlistbuild-bigtile.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)
         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

         float3 result = float3(1.0, 0.0, 1.0);
         bool needLinearToSRGB = false;
 
+        GetPropertiesDataDebug(_DebugViewMaterial, result, needLinearToSRGB);
         GetVaryingsDataDebug(_DebugViewMaterial, input, result, needLinearToSRGB);
         GetBuiltinDataDebug(_DebugViewMaterial, builtinData, result, needLinearToSRGB);
         GetSurfaceDataDebug(_DebugViewMaterial, surfaceData, result, needLinearToSRGB);

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/ShaderLibrary/Shadow/Shadow.hlsl

 
 
 // shadow sampling prototypes
-float GetPunctualShadowAttenuation( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float3 L );
-float GetPunctualShadowAttenuation( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float3 L, float2 unPositionSS );
+float GetPunctualShadowAttenuation( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float4 L );
+float GetPunctualShadowAttenuation( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float4 L, float2 unPositionSS );
 // shadow sampling prototypes with screenspace info
 float GetDirectionalShadowAttenuation( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float3 L );
 float GetDirectionalShadowAttenuation( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float3 L, float2 unPositionSS );
 
 // default dispatchers for the individual shadow types (with and without screenspace support)
 // point/spot light shadows
-float GetPunctualShadowAttenuationDefault( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float3 L )
+float GetPunctualShadowAttenuationDefault( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float4 L )
-float GetPunctualShadowAttenuationDefault( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float3 L, float2 unPositionSS )
+float GetPunctualShadowAttenuationDefault( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float4 L, float2 unPositionSS )
 {
 	return GetPunctualShadowAttenuationDefault( shadowContext, positionWS, normalWS, shadowDataIndex, L );
 }
 
 // if shadow dispatch is empty we'll fall back to default shadow sampling implementations
 #ifndef SHADOW_DISPATCH_USE_CUSTOM_PUNCTUAL
-float GetPunctualShadowAttenuation( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float3 L )
+float GetPunctualShadowAttenuation( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float4 L )
-float GetPunctualShadowAttenuation( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float3 L, float2 unPositionSS )
+float GetPunctualShadowAttenuation( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float4 L, float2 unPositionSS )
 {
 	return GetPunctualShadowAttenuationDefault( shadowContext, positionWS, normalWS, shadowDataIndex, L, unPositionSS );
 }

Assets/ScriptableRenderPipeline/ShaderLibrary/Shadow/ShadowAlgorithms.hlsl

 //
 //	Point shadows
 //
-float EvalShadow_PointDepth( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int index, float3 L )
+float EvalShadow_PointDepth( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int index, float4 L )
+	ShadowData sd = shadowContext.shadowDatas[index];
+	float3 biased_posWS = positionWS + EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L.xyz ) ), sd.texelSizeRcp.zw, sd.normalBias );
+	float3 lpos   = positionWS + L.xyz * L.w;
+	positionWS    = biased_posWS;
+	int faceIndex = EvalShadow_GetCubeFaceID( lpos - biased_posWS ) + 1;
-	int faceIndex = EvalShadow_GetCubeFaceID( L ) + 1;
-	ShadowData sd = shadowContext.shadowDatas[index + faceIndex];
+	sd = shadowContext.shadowDatas[index + faceIndex];
-	positionWS += EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L ) ), sd.texelSizeRcp.zw, sd.normalBias );
+	positionWS += EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L.xyz ) ), sd.texelSizeRcp.zw, sd.normalBias );
 	// get shadowmap texcoords
 	float3 posTC = EvalShadow_GetTexcoords( sd, positionWS );
 	// get the algorithm
 }
 
 #define EvalShadow_PointDepth_( _samplerType )																																			\
-	float EvalShadow_PointDepth( ShadowContext shadowContext, uint shadowAlgorithm, Texture2DArray tex, _samplerType samp, float3 positionWS, float3 normalWS, int index, float3 L )	\
+	float EvalShadow_PointDepth( ShadowContext shadowContext, uint shadowAlgorithm, Texture2DArray tex, _samplerType samp, float3 positionWS, float3 normalWS, int index, float4 L )	\
+		ShadowData sd = shadowContext.shadowDatas[index];                                                                                                                               \
+		float3 biased_posWS = positionWS + EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L.xyz ) ), sd.texelSizeRcp.zw, sd.normalBias );                                    \
+		float3 lpos   = positionWS + L.xyz * L.w;                                                                                                                                       \
+		positionWS    = biased_posWS;                                                                                                                                                   \
+		int faceIndex = EvalShadow_GetCubeFaceID( lpos - biased_posWS ) + 1;                                                                                                            \
-		int faceIndex =  EvalShadow_GetCubeFaceID( L ) + 1;																																\
-		ShadowData sd = shadowContext.shadowDatas[index + faceIndex];																													\
+		sd = shadowContext.shadowDatas[index + faceIndex];																													            \
-		positionWS += EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L ) ), sd.texelSizeRcp.zw, sd.normalBias );																\
+		positionWS += EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L.xyz ) ), sd.texelSizeRcp.zw, sd.normalBias );															\
 		/* get shadowmap texcoords */																																					\
 		float3 posTC = EvalShadow_GetTexcoords( sd, positionWS );																														\
 		/* sample the texture */																																						\
 		ShadowData sd = shadowContext.shadowDatas[index];																															\
 		uint payloadOffset = GetPayloadOffset( sd );																																\
 		/* normal based bias */																																						\
-		positionWS += EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L ) ), sd.texelSizeRcp.zw, sd.normalBias );															\
+		positionWS += EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L ) ), sd.texelSizeRcp.zw, sd.normalBias );														    \
 		/* get shadowmap texcoords */																																				\
 		float3 posTC = EvalShadow_GetTexcoords( sd, positionWS );																													\
 		/* sample the texture */																																					\
 //
 //	Punctual shadows for Point and Spot
 //
-float EvalShadow_PunctualDepth( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int index, float3 L )
+float EvalShadow_PunctualDepth( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int index, float4 L )
+	ShadowData sd = shadowContext.shadowDatas[index];
-	UnpackShadowType( shadowContext.shadowDatas[index].shadowType, shadowType );
+	UnpackShadowType( sd.shadowType, shadowType );
-		faceIndex = EvalShadow_GetCubeFaceID( L ) + 1;
+		float3 biased_posWS = positionWS + EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L.xyz ) ), sd.texelSizeRcp.zw, sd.normalBias );
+		float3 lpos = positionWS + L.xyz * L.w;
+		positionWS  = biased_posWS;
+		faceIndex   = EvalShadow_GetCubeFaceID( lpos - biased_posWS ) + 1;
+	else
+		positionWS += EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L.xyz ) ), sd.texelSizeRcp.zw, sd.normalBias );
-	ShadowData sd = shadowContext.shadowDatas[index + faceIndex];
+	sd = shadowContext.shadowDatas[index + faceIndex];
-	// normal based bias
-	positionWS += EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L ) ), sd.texelSizeRcp.zw, sd.normalBias );
 	// get shadowmap texcoords
 	float3 posTC = EvalShadow_GetTexcoords( sd, positionWS );
 	// sample the texture according to the given algorithm
 	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);
+}
-	float EvalShadow_PunctualDepth( ShadowContext shadowContext, uint shadowAlgorithm, Texture2DArray tex, _samplerType samp, float3 positionWS, float3 normalWS, int index, float3 L )	\
+	float EvalShadow_PunctualDepth( ShadowContext shadowContext, uint shadowAlgorithm, Texture2DArray tex, _samplerType samp, float3 positionWS, float3 normalWS, int index, float4 L )	\
+		ShadowData sd = shadowContext.shadowDatas[index];                                                                                                                               \
-		UnpackShadowType( shadowContext.shadowDatas[index].shadowType, shadowType );																									\
+		UnpackShadowType( sd.shadowType, shadowType );																									                                \
-			faceIndex = EvalShadow_GetCubeFaceID( L ) + 1;																																\
+			float3 biased_posWS = positionWS + EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L.xyz ) ), sd.texelSizeRcp.zw, sd.normalBias );                                \
+			float3 lpos = positionWS + L.xyz * L.w;                                                                                                                                     \
+			positionWS  = biased_posWS;                                                                                                                                                 \
+			faceIndex   = EvalShadow_GetCubeFaceID( lpos - biased_posWS ) + 1;																											\
+		else																																											\
+			positionWS += EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L.xyz ) ), sd.texelSizeRcp.zw, sd.normalBias );														\
-		ShadowData sd = shadowContext.shadowDatas[index + faceIndex];																													\
+		sd = shadowContext.shadowDatas[index + faceIndex];																													            \
-		/* normal based bias */																																							\
-		positionWS += EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L ) ), sd.texelSizeRcp.zw, sd.normalBias );																\
 		/* get shadowmap texcoords */																																					\
 		float3 posTC = EvalShadow_GetTexcoords( sd, positionWS );																														\
 		/* sample the texture */																																						\
 
 float EvalShadow_CascadedDepth( ShadowContext shadowContext, 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 );
 
-	ShadowData sd = shadowContext.shadowDatas[index + 1 + shadowSplitIndex];
-	// normal based bias
-	positionWS += EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L ) ), sd.texelSizeRcp.zw, sd.normalBias );
+	sd = shadowContext.shadowDatas[index + 1 + shadowSplitIndex];
 	// get shadowmap texcoords
 	float3 posTC = EvalShadow_GetTexcoords( sd, positionWS );
 
 #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 );																				\
 																																														\
-		ShadowData sd = shadowContext.shadowDatas[index + 1 + shadowSplitIndex];																										\
-		/* normal based bias */																																							\
-		positionWS += EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L ) ), sd.texelSizeRcp.zw, sd.normalBias );																\
+		sd = shadowContext.shadowDatas[index + 1 + shadowSplitIndex];																										            \
 		/* get shadowmap texcoords */																																					\
 		float3 posTC = EvalShadow_GetTexcoords( sd, positionWS );																														\
 		/* sample the texture */																																						\

Assets/ScriptableRenderPipeline/ShaderLibrary/Shadow/ShadowAlgorithmsCustom.hlsl

 
 float EvalShadow_CascadedMoment( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float3 L )
 {
+	ShadowData sd = shadowContext.shadowDatas[shadowDataIndex];
+	// 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, shadowDataIndex, dirShadowSplitSpheres );
 
-	ShadowData sd = shadowContext.shadowDatas[shadowDataIndex + 1 + shadowSplitIndex];
-	// normal based bias
-	positionWS += EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L ) ), sd.texelSizeRcp.zw, sd.normalBias );
+	// get the shadowmap data for the correct cascade
+	sd = shadowContext.shadowDatas[shadowDataIndex + 1 + shadowSplitIndex];
+
 	// get shadowmap texcoords
 	float3 posTC = EvalShadow_GetTexcoords( sd, positionWS );
 

Assets/ScriptableRenderPipeline/ShaderLibrary/Shadow/ShadowMoments.hlsl

 	float mD = depth - moments.x;
 	float p = variance / (variance + mD * mD);
 
-	p = saturate( p / (1.0f - lightLeakBias) );
+	p = saturate( (p - lightLeakBias) / (1.0f - lightLeakBias) );
 	return max( p, depth <= moments.x );
 }
 

Assets/TestScenes/HDTest/BasicProfiling.unity

   affectDiffuse: 1
   affectSpecular: 1
   archetype: 1
+  spotLightShape: 0
   lightLength: 0
   lightWidth: 0
 --- !u!108 &31226894
   m_Lightmapping: 4
   m_AreaSize: {x: 1, y: 1}
   m_BounceIntensity: 1
-  m_FalloffTable:
-    m_Table[0]: 0
-    m_Table[1]: 0
-    m_Table[2]: 0
-    m_Table[3]: 0
-    m_Table[4]: 0
-    m_Table[5]: 0
-    m_Table[6]: 0
-    m_Table[7]: 0
-    m_Table[8]: 0
-    m_Table[9]: 0
-    m_Table[10]: 0
-    m_Table[11]: 0
-    m_Table[12]: 0
   m_ColorTemperature: 6570
   m_UseColorTemperature: 0
   m_ShadowRadius: 0
   affectDiffuse: 1
   affectSpecular: 1
   archetype: 1
+  spotLightShape: 0
   lightLength: 0
   lightWidth: 0
 --- !u!108 &119724878
   m_Lightmapping: 4
   m_AreaSize: {x: 1, y: 1}
   m_BounceIntensity: 1
-  m_FalloffTable:
-    m_Table[0]: 0
-    m_Table[1]: 0
-    m_Table[2]: 0
-    m_Table[3]: 0
-    m_Table[4]: 0
-    m_Table[5]: 0
-    m_Table[6]: 0
-    m_Table[7]: 0
-    m_Table[8]: 0
-    m_Table[9]: 0
-    m_Table[10]: 0
-    m_Table[11]: 0
-    m_Table[12]: 0
   m_ColorTemperature: 6570
   m_UseColorTemperature: 0
   m_ShadowRadius: 0
   affectDiffuse: 1
   affectSpecular: 1
   archetype: 1
+  spotLightShape: 0
   lightLength: 0
   lightWidth: 0
 --- !u!108 &290893317
   m_Lightmapping: 4
   m_AreaSize: {x: 1, y: 1}
   m_BounceIntensity: 1
-  m_FalloffTable:
-    m_Table[0]: 0
-    m_Table[1]: 0
-    m_Table[2]: 0
-    m_Table[3]: 0
-    m_Table[4]: 0
-    m_Table[5]: 0
-    m_Table[6]: 0
-    m_Table[7]: 0
-    m_Table[8]: 0
-    m_Table[9]: 0
-    m_Table[10]: 0
-    m_Table[11]: 0
-    m_Table[12]: 0
   m_ColorTemperature: 6570
   m_UseColorTemperature: 0
   m_ShadowRadius: 0
   affectDiffuse: 1
   affectSpecular: 1
   archetype: 0
+  spotLightShape: 0
   lightLength: 0
   lightWidth: 0
 --- !u!108 &578289780
   m_Lightmapping: 4
   m_AreaSize: {x: 1, y: 1}
   m_BounceIntensity: 1
-  m_FalloffTable:
-    m_Table[0]: 0
-    m_Table[1]: 0
-    m_Table[2]: 0
-    m_Table[3]: 0
-    m_Table[4]: 0
-    m_Table[5]: 0
-    m_Table[6]: 0
-    m_Table[7]: 0
-    m_Table[8]: 0
-    m_Table[9]: 0
-    m_Table[10]: 0
-    m_Table[11]: 0
-    m_Table[12]: 0
   m_ColorTemperature: 6570
   m_UseColorTemperature: 0
   m_ShadowRadius: 0
   affectDiffuse: 1
   affectSpecular: 1
   archetype: 1
+  spotLightShape: 0
   lightLength: 0
   lightWidth: 0
 --- !u!108 &1028064555
   m_Lightmapping: 4
   m_AreaSize: {x: 1, y: 1}
   m_BounceIntensity: 1
-  m_FalloffTable:
-    m_Table[0]: 0
-    m_Table[1]: 0
-    m_Table[2]: 0
-    m_Table[3]: 0
-    m_Table[4]: 0
-    m_Table[5]: 0
-    m_Table[6]: 0
-    m_Table[7]: 0
-    m_Table[8]: 0
-    m_Table[9]: 0
-    m_Table[10]: 0
-    m_Table[11]: 0
-    m_Table[12]: 0
   m_ColorTemperature: 6570
   m_UseColorTemperature: 0
   m_ShadowRadius: 0
   m_Lightmapping: 4
   m_AreaSize: {x: 1, y: 1}
   m_BounceIntensity: 1
-  m_FalloffTable:
-    m_Table[0]: 0
-    m_Table[1]: 0
-    m_Table[2]: 0
-    m_Table[3]: 0
-    m_Table[4]: 0
-    m_Table[5]: 0
-    m_Table[6]: 0
-    m_Table[7]: 0
-    m_Table[8]: 0
-    m_Table[9]: 0
-    m_Table[10]: 0
-    m_Table[11]: 0
-    m_Table[12]: 0
   m_ColorTemperature: 6570
   m_UseColorTemperature: 0
   m_ShadowRadius: 0
   affectDiffuse: 1
   affectSpecular: 1
   archetype: 0
+  spotLightShape: 0
   lightLength: 0
   lightWidth: 0
 --- !u!1 &1224712456
   affectDiffuse: 1
   affectSpecular: 1
   archetype: 1
+  spotLightShape: 0
   lightLength: 0
   lightWidth: 0
 --- !u!108 &1369123404
   m_Lightmapping: 4
   m_AreaSize: {x: 1, y: 1}
   m_BounceIntensity: 1
-  m_FalloffTable:
-    m_Table[0]: 0
-    m_Table[1]: 0
-    m_Table[2]: 0
-    m_Table[3]: 0
-    m_Table[4]: 0
-    m_Table[5]: 0
-    m_Table[6]: 0
-    m_Table[7]: 0
-    m_Table[8]: 0
-    m_Table[9]: 0
-    m_Table[10]: 0
-    m_Table[11]: 0
-    m_Table[12]: 0
   m_ColorTemperature: 6570
   m_UseColorTemperature: 0
   m_ShadowRadius: 0
   affectDiffuse: 1
   affectSpecular: 1
   archetype: 1
+  spotLightShape: 0
   lightLength: 0
   lightWidth: 0
 --- !u!108 &1418455419
   m_Lightmapping: 4
   m_AreaSize: {x: 1, y: 1}
   m_BounceIntensity: 1
-  m_FalloffTable:
-    m_Table[0]: 0
-    m_Table[1]: 0
-    m_Table[2]: 0
-    m_Table[3]: 0
-    m_Table[4]: 0
-    m_Table[5]: 0
-    m_Table[6]: 0
-    m_Table[7]: 0
-    m_Table[8]: 0
-    m_Table[9]: 0
-    m_Table[10]: 0
-    m_Table[11]: 0
-    m_Table[12]: 0
   m_ColorTemperature: 6570
   m_UseColorTemperature: 0
   m_ShadowRadius: 0
   affectDiffuse: 1
   affectSpecular: 1
   archetype: 0
+  spotLightShape: 0
   lightLength: 0
   lightWidth: 0
 --- !u!108 &1685118384
   m_Lightmapping: 4
   m_AreaSize: {x: 1, y: 1}
   m_BounceIntensity: 1
-  m_FalloffTable:
-    m_Table[0]: 0
-    m_Table[1]: 0
-    m_Table[2]: 0
-    m_Table[3]: 0
-    m_Table[4]: 0
-    m_Table[5]: 0
-    m_Table[6]: 0
-    m_Table[7]: 0
-    m_Table[8]: 0
-    m_Table[9]: 0
-    m_Table[10]: 0
-    m_Table[11]: 0
-    m_Table[12]: 0
   m_ColorTemperature: 6570
   m_UseColorTemperature: 0
   m_ShadowRadius: 0
   affectDiffuse: 1
   affectSpecular: 1
   archetype: 0
+  spotLightShape: 0
   lightLength: 0
   lightWidth: 0
 --- !u!108 &1736085185
   m_Lightmapping: 4
   m_AreaSize: {x: 1, y: 1}
   m_BounceIntensity: 1
-  m_FalloffTable:
-    m_Table[0]: 0
-    m_Table[1]: 0
-    m_Table[2]: 0
-    m_Table[3]: 0
-    m_Table[4]: 0
-    m_Table[5]: 0
-    m_Table[6]: 0
-    m_Table[7]: 0
-    m_Table[8]: 0
-    m_Table[9]: 0
-    m_Table[10]: 0
-    m_Table[11]: 0
-    m_Table[12]: 0
   m_ColorTemperature: 6570
   m_UseColorTemperature: 0
   m_ShadowRadius: 0
   affectDiffuse: 1
   affectSpecular: 1
   archetype: 0
+  spotLightShape: 0
   lightLength: 0
   lightWidth: 0
 --- !u!108 &1866152053
   m_Lightmapping: 4
   m_AreaSize: {x: 1, y: 1}
   m_BounceIntensity: 1
-  m_FalloffTable:
-    m_Table[0]: 0
-    m_Table[1]: 0
-    m_Table[2]: 0
-    m_Table[3]: 0
-    m_Table[4]: 0
-    m_Table[5]: 0
-    m_Table[6]: 0
-    m_Table[7]: 0
-    m_Table[8]: 0
-    m_Table[9]: 0
-    m_Table[10]: 0
-    m_Table[11]: 0
-    m_Table[12]: 0
   m_ColorTemperature: 6570
   m_UseColorTemperature: 0
   m_ShadowRadius: 0
   affectDiffuse: 1
   affectSpecular: 1
   archetype: 0
+  spotLightShape: 0
   lightLength: 0
   lightWidth: 0
 --- !u!108 &1955890979
   m_Lightmapping: 4
   m_AreaSize: {x: 1, y: 1}
   m_BounceIntensity: 1
-  m_FalloffTable:
-    m_Table[0]: 0
-    m_Table[1]: 0
-    m_Table[2]: 0
-    m_Table[3]: 0
-    m_Table[4]: 0
-    m_Table[5]: 0
-    m_Table[6]: 0
-    m_Table[7]: 0
-    m_Table[8]: 0
-    m_Table[9]: 0
-    m_Table[10]: 0
-    m_Table[11]: 0
-    m_Table[12]: 0
   m_ColorTemperature: 6570
   m_UseColorTemperature: 0
   m_ShadowRadius: 0
   affectDiffuse: 1
   affectSpecular: 1
   archetype: 0
+  spotLightShape: 0
   lightLength: 0
   lightWidth: 0
 --- !u!108 &1964619977
   m_Lightmapping: 4
   m_AreaSize: {x: 1, y: 1}
   m_BounceIntensity: 1
-  m_FalloffTable:
-    m_Table[0]: 0
-    m_Table[1]: 0
-    m_Table[2]: 0
-    m_Table[3]: 0
-    m_Table[4]: 0
-    m_Table[5]: 0
-    m_Table[6]: 0
-    m_Table[7]: 0
-    m_Table[8]: 0
-    m_Table[9]: 0
-    m_Table[10]: 0
-    m_Table[11]: 0
-    m_Table[12]: 0
   m_ColorTemperature: 6570
   m_UseColorTemperature: 0
   m_ShadowRadius: 0

ProjectSettings/ProjectVersion.txt

-m_EditorVersion: 2017.3.0a1
+m_EditorVersion: 2017.3.0a2

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
+
+// TODO: We should remove these variant for cluster opaque and only keep tile 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 = groupId;
+    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/LitReference.hlsl

+//-----------------------------------------------------------------------------
+// EvaluateBSDF_Line - Reference
+//-----------------------------------------------------------------------------
+
+void IntegrateBSDF_LineRef(float3 V, float3 positionWS,
+                           PreLightData preLightData, LightData lightData, BSDFData bsdfData,
+                           out float3 diffuseLighting, out float3 specularLighting,
+                           int sampleCount = 128)
+{
+    diffuseLighting  = float3(0.0, 0.0, 0.0);
+    specularLighting = float3(0.0, 0.0, 0.0);
+
+    const float  len = lightData.size.x;
+    const float3 T   = lightData.right;
+    const float3 P1  = lightData.positionWS - T * (0.5 * len);
+    const float  dt  = len * rcp(sampleCount);
+    const float  off = 0.5 * dt;
+
+    // Uniformly sample the line segment with the Pdf = 1 / len.
+    const float invPdf = len;
+
+    for (int i = 0; i < sampleCount; ++i)
+    {
+        // Place the sample in the middle of the interval.
+        float  t     = off + i * dt;
+        float3 sPos  = P1 + t * T;
+        float3 unL   = sPos - positionWS;
+        float  dist2 = dot(unL, unL);
+        float3 L     = normalize(unL);
+        float  sinLT = length(cross(L, T));
+        float  NdotL = saturate(dot(bsdfData.normalWS, L));
+
+        if (NdotL > 0)
+        {
+            float3 lightDiff, lightSpec;
+
+            BSDF(V, L, positionWS, preLightData, bsdfData, lightDiff, lightSpec);
+
+            diffuseLighting  += lightDiff * (sinLT / dist2 * NdotL);
+            specularLighting += lightSpec * (sinLT / dist2 * NdotL);
+        }
+    }
+
+    // The factor of 2 is due to the fact: Integral{0, 2 PI}{max(0, cos(x))dx} = 2.
+    float normFactor = 2.0 * invPdf * rcp(sampleCount);
+
+    diffuseLighting  *= normFactor * lightData.diffuseScale  * lightData.color;
+    specularLighting *= normFactor * lightData.specularScale * lightData.color;
+}
+
+//-----------------------------------------------------------------------------
+// EvaluateBSDF_Area - Reference
+//-----------------------------------------------------------------------------
+
+void IntegrateBSDF_AreaRef(float3 V, float3 positionWS,
+                           PreLightData preLightData, LightData lightData, BSDFData bsdfData,
+                           out float3 diffuseLighting, out float3 specularLighting,
+                           uint sampleCount = 512)
+{
+    // Add some jittering on Hammersley2d
+    float2 randNum = InitRandom(V.xy * 0.5 + 0.5);
+
+    diffuseLighting = float3(0.0, 0.0, 0.0);
+    specularLighting = float3(0.0, 0.0, 0.0);
+
+    for (uint i = 0; i < sampleCount; ++i)
+    {
+        float3 P = float3(0.0, 0.0, 0.0);   // Sample light point. Random point on the light shape in local space.
+        float3 Ns = float3(0.0, 0.0, 0.0);  // Unit surface normal at P
+        float lightPdf = 0.0;               // Pdf of the light sample
+
+        float2 u = Hammersley2d(i, sampleCount);
+        u = frac(u + randNum);
+
+        // Lights in Unity point backward.
+        float4x4 localToWorld = float4x4(float4(lightData.right, 0.0), float4(lightData.up, 0.0), float4(-lightData.forward, 0.0), float4(lightData.positionWS, 1.0));
+
+        switch (lightData.lightType)
+        {
+            case GPULIGHTTYPE_SPHERE:
+                SampleSphere(u, localToWorld, lightData.size.x, lightPdf, P, Ns);
+                break;
+            case GPULIGHTTYPE_HEMISPHERE:
+                SampleHemisphere(u, localToWorld, lightData.size.x, lightPdf, P, Ns);
+                break;
+            case GPULIGHTTYPE_CYLINDER:
+                SampleCylinder(u, localToWorld, lightData.size.x, lightData.size.y, lightPdf, P, Ns);
+                break;
+            case GPULIGHTTYPE_RECTANGLE:
+                SampleRectangle(u, localToWorld, lightData.size.x, lightData.size.y, lightPdf, P, Ns);
+                break;
+            case GPULIGHTTYPE_DISK:
+                SampleDisk(u, localToWorld, lightData.size.x, lightPdf, P, Ns);
+                break;
+            // case GPULIGHTTYPE_LINE: handled by a separate function.
+        }
+
+        // Get distance
+        float3 unL = P - positionWS;
+        float sqrDist = dot(unL, unL);
+        float3 L = normalize(unL);
+
+        // Cosine of the angle between the light direction and the normal of the light's surface.
+        float cosLNs = saturate(dot(-L, Ns));
+
+        // We calculate area reference light with the area integral rather than the solid angle one.
+        float illuminance = cosLNs * saturate(dot(bsdfData.normalWS, L)) / (sqrDist * lightPdf);
+
+        float3 localDiffuseLighting = float3(0.0, 0.0, 0.0);
+        float3 localSpecularLighting = float3(0.0, 0.0, 0.0);
+
+        if (illuminance > 0.0)
+        {
+            BSDF(V, L, positionWS, preLightData, bsdfData, localDiffuseLighting, localSpecularLighting);
+            localDiffuseLighting *= lightData.color * illuminance * lightData.diffuseScale;
+            localSpecularLighting *= lightData.color * illuminance * lightData.specularScale;
+        }
+
+        diffuseLighting += localDiffuseLighting;
+        specularLighting += localSpecularLighting;
+    }
+
+    diffuseLighting /= float(sampleCount);
+    specularLighting /= float(sampleCount);
+}
+
+//-----------------------------------------------------------------------------
+// EvaluateBSDF_Env - Reference
+// ----------------------------------------------------------------------------
+
+// Ref: Moving Frostbite to PBR (Appendix A)
+float3 IntegrateLambertIBLRef(LightLoopContext lightLoopContext,
+                              float3 V, EnvLightData lightData, BSDFData bsdfData,
+                              uint sampleCount = 4096)
+{
+    float3x3 localToWorld = float3x3(bsdfData.tangentWS, bsdfData.bitangentWS, bsdfData.normalWS);
+    float3   acc          = float3(0.0, 0.0, 0.0);
+
+    // Add some jittering on Hammersley2d
+    float2 randNum  = InitRandom(V.xy * 0.5 + 0.5);
+
+    for (uint i = 0; i < sampleCount; ++i)
+    {
+        float2 u    = Hammersley2d(i, sampleCount);
+        u           = frac(u + randNum);
+
+        float3 L;
+        float NdotL;
+        float weightOverPdf;
+        ImportanceSampleLambert(u, localToWorld, L, NdotL, weightOverPdf);
+
+        if (NdotL > 0.0)
+        {
+            float4 val = SampleEnv(lightLoopContext, lightData.envIndex, L, 0);
+
+            // diffuse Albedo is apply here as describe in ImportanceSampleLambert function
+            acc += bsdfData.diffuseColor * LambertNoPI() * weightOverPdf * val.rgb;
+        }
+    }
+
+    return acc / sampleCount;
+}
+
+float3 IntegrateDisneyDiffuseIBLRef(LightLoopContext lightLoopContext,
+                                    float3 V, PreLightData preLightData, EnvLightData lightData, BSDFData bsdfData,
+                                    uint sampleCount = 4096)
+{
+    float3x3 localToWorld = float3x3(bsdfData.tangentWS, bsdfData.bitangentWS, bsdfData.normalWS);
+    float    NdotV        = max(preLightData.NdotV, MIN_N_DOT_V);
+    float3   acc          = float3(0.0, 0.0, 0.0);
+
+    // Add some jittering on Hammersley2d
+    float2 randNum  = InitRandom(V.xy * 0.5 + 0.5);
+
+    for (uint i = 0; i < sampleCount; ++i)
+    {
+        float2 u    = Hammersley2d(i, sampleCount);
+        u           = frac(u + randNum);
+
+        float3 L;
+        float NdotL;
+        float weightOverPdf;
+        // for Disney we still use a Cosine importance sampling, true Disney importance sampling imply a look up table
+        ImportanceSampleLambert(u, localToWorld, L, NdotL, weightOverPdf);
+
+        if (NdotL > 0.0)
+        {
+            float3 H = normalize(L + V);
+            float LdotH = dot(L, H);
+            // Note: we call DisneyDiffuse that require to multiply by Albedo / PI. Divide by PI is already taken into account
+            // in weightOverPdf of ImportanceSampleLambert call.
+            float disneyDiffuse = DisneyDiffuse(NdotV, NdotL, LdotH, bsdfData.perceptualRoughness);
+
+            // diffuse Albedo is apply here as describe in ImportanceSampleLambert function
+            float4 val = SampleEnv(lightLoopContext, lightData.envIndex, L, 0);
+            acc += bsdfData.diffuseColor * disneyDiffuse * weightOverPdf * val.rgb;
+        }
+    }
+
+    return acc / sampleCount;
+}
+
+// Ref: Moving Frostbite to PBR (Appendix A)
+float3 IntegrateSpecularGGXIBLRef(LightLoopContext lightLoopContext,
+                                  float3 V, PreLightData preLightData, EnvLightData lightData, BSDFData bsdfData,
+                                  uint sampleCount = 4096)
+{
+    float3x3 localToWorld = float3x3(bsdfData.tangentWS, bsdfData.bitangentWS, bsdfData.normalWS);
+    float    NdotV        = max(preLightData.NdotV, MIN_N_DOT_V);
+    float3   acc          = float3(0.0, 0.0, 0.0);
+
+    // Add some jittering on Hammersley2d
+    float2 randNum  = InitRandom(V.xy * 0.5 + 0.5);
+
+    for (uint i = 0; i < sampleCount; ++i)
+    {
+        float2 u    = Hammersley2d(i, sampleCount);
+        u           = frac(u + randNum);
+
+        float VdotH;
+        float NdotL;
+        float3 L;
+        float weightOverPdf;
+
+        // GGX BRDF
+        if (bsdfData.materialId == MATERIALID_LIT_ANISO)
+        {
+            ImportanceSampleAnisoGGX(u, V, localToWorld, bsdfData.roughnessT, bsdfData.roughnessB, NdotV, L, VdotH, NdotL, weightOverPdf);
+        }
+        else
+        {
+            ImportanceSampleGGX(u, V, localToWorld, bsdfData.roughness, NdotV, L, VdotH, NdotL, weightOverPdf);
+        }
+
+
+        if (NdotL > 0.0)
+        {
+            // Fresnel component is apply here as describe in ImportanceSampleGGX function
+            float3 FweightOverPdf = F_Schlick(bsdfData.fresnel0, VdotH) * weightOverPdf;
+
+            float4 val = SampleEnv(lightLoopContext, lightData.envIndex, L, 0);
+
+            acc += FweightOverPdf * val.rgb;
+        }
+    }
+
+    return acc / sampleCount;
+}

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

+fileFormatVersion: 2
+guid: 0406917314064054eb0ef42f727a8889
+timeCreated: 1500913760
+licenseType: Pro
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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: 

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
-
-//-------------------------------------------------------------------------------------
-// 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);
-    }
-}
-