Split directional shadow resolution in a different pass to reduce VGPR pressure during tile lighting.

SampleScenes/HDTest/ShadowsTest.unity

   m_PrefabParentObject: {fileID: 4211168484685708, guid: e1e5df6b963abe54ea96453a0a5f4c5d,
     type: 2}
   m_PrefabInternal: {fileID: 240371583}
+--- !u!1 &240603307
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 240603311}
+  - component: {fileID: 240603310}
+  - component: {fileID: 240603309}
+  - component: {fileID: 240603308}
+  m_Layer: 0
+  m_Name: Camera_FullScreen
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!81 &240603308
+AudioListener:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 240603307}
+  m_Enabled: 1
+  m_ExtensionPropertyValues: []
+--- !u!124 &240603309
+Behaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 240603307}
+  m_Enabled: 1
+--- !u!20 &240603310
+Camera:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 240603307}
+  m_Enabled: 1
+  serializedVersion: 2
+  m_ClearFlags: 1
+  m_BackGroundColor: {r: 0.19215687, g: 0.3019608, b: 0.4745098, a: 0}
+  m_NormalizedViewPortRect:
+    serializedVersion: 2
+    x: 0
+    y: 0
+    width: 1
+    height: 1
+  near clip plane: 0.3
+  far clip plane: 1000
+  field of view: 60
+  orthographic: 0
+  orthographic size: 5
+  m_Depth: 0
+  m_CullingMask:
+    serializedVersion: 2
+    m_Bits: 4294967295
+  m_RenderingPath: -1
+  m_TargetTexture: {fileID: 0}
+  m_TargetDisplay: 0
+  m_TargetEye: 3
+  m_HDR: 1
+  m_AllowMSAA: 1
+  m_AllowDynamicResolution: 0
+  m_ForceIntoRT: 0
+  m_OcclusionCulling: 1
+  m_StereoConvergence: 10
+  m_StereoSeparation: 0.022
+  m_StereoMirrorMode: 0
+--- !u!4 &240603311
+Transform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 240603307}
+  m_LocalRotation: {x: 0.04375193, y: -0.044928193, z: 0.001950043, w: 0.9980298}
+  m_LocalPosition: {x: 227.8387, y: 4.7424283, z: 66.025215}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 14
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
 --- !u!1001 &241568988
 Prefab:
   m_ObjectHideFlags: 0
   - 0.028
   - 0.18
   shadowCascadeBorders:
-  - 0.563
-  - 0.285
-  - 0
-  - 0
+  - 0.333
+  - 0.322
+  - 0.272
+  - 0.356
-    data: 99bb163b0000803f
+    data: 6f12833b0000803f
-    data: 99bb163b0000803f
+    data: 6f12833b0000803f
   - format: 24
     data: 5839b43d000000000bd7233c02000000
   - format: 16
   - {fileID: 1558117777}
   - {fileID: 2095847159}
   - {fileID: 1232280521}
+  - {fileID: 240603310}
 --- !u!114 &1769631035
 MonoBehaviour:
   m_ObjectHideFlags: 0

ScriptableRenderPipeline/Core/ShaderLibrary/Shadow/ShadowAlgorithms.hlsl

 	float3 orig_pos = positionWS;
 	uint orig_payloadOffset = payloadOffset;
 	positionWS += EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L ) ), scales[shadowSplitIndex] * sd.texelSizeRcp.zw, sd.normalBias );
+
+    /* Be careful of this code, we need it here before the if statement otherwise the compiler screws up optimizing dirShadowSplitSpheres VGPRs away */
+    float border = borders[shadowSplitIndex];
+	float alpha  = border <= 0.0 ? 0.0 : saturate( (relDistance - (1.0 - border)) / border );
+    float4 splitSphere = dirShadowSplitSpheres[shadowSplitIndex];
+	float3 cascadeDir  = normalize( -splitSphere.xyz + dirShadowSplitSpheres[min(3,shadowSplitIndex+1)].xyz );
+	float3 wposDir     = normalize( -splitSphere.xyz + positionWS );
+	float  cascDot     = dot( cascadeDir, wposDir );
+	alpha = cascDot > 0.0 ? alpha : lerp( alpha, 0.0, saturate( -cascDot * 4.0 ) );
+
 	// get shadowmap texcoords
 	float3 posNDC;
 	float3 posTC = EvalShadow_GetTexcoords( sd, positionWS, posNDC, true );
 	UnpackShadowType( sd.shadowType, shadowType, shadowAlgorithm );
 	float shadow = SampleShadow_SelectAlgorithm( shadowContext, sd, payloadOffset, posTC, sd.bias, slice, shadowAlgorithm, texIdx, sampIdx );
 
-	float border = borders[shadowSplitIndex];
-	float alpha  = border <= 0.0 ? 0.0 : saturate( (relDistance - (1.0 - border)) / border );
-
-		float4 splitSphere = dirShadowSplitSpheres[shadowSplitIndex - 1];
-		float3 cascadeDir  = normalize( -splitSphere.xyz + dirShadowSplitSpheres[shadowSplitIndex].xyz );
-		float3 wposDir     = normalize( -splitSphere.xyz + positionWS );
-		float  cascDot     = dot( cascadeDir, wposDir );
-		alpha   = cascDot > 0.0 ? alpha : lerp( alpha, 0.0, saturate( -cascDot * 4.0 ) );
 		shadow1 = shadow;
 
 		[branch]
 		payloadOffset++;                                                                                                                                                                        \
 		float4 borders = asfloat( shadowContext.payloads[payloadOffset] );                                                                                                                      \
 		payloadOffset++;                                                                                                                                                                        \
-																																																\
-		uint   orig_payloadOffset = payloadOffset;		                                                                                                                                        \
+		uint orig_payloadOffset = payloadOffset;		                                                                                                                                        \
-		/* get shadowmap texcoords */																																					        \
+                                                                                                                                                                                                \
+        /* Be careful of this code, we need it here before the if statement otherwise the compiler screws up optimizing dirShadowSplitSpheres VGPRs away */                                     \
+		float border = borders[shadowSplitIndex];                                                                                                                                               \
+		float alpha  = border <= 0.0 ? 0.0 : saturate( (relDistance - (1.0 - border)) / border );                                                                                               \
+        float4 splitSphere = dirShadowSplitSpheres[shadowSplitIndex];                                                                                                                           \
+		float3 cascadeDir  = normalize( -splitSphere.xyz + dirShadowSplitSpheres[min(kMaxShadowCascades-1,shadowSplitIndex+1)].xyz );                                                           \
+		float3 wposDir     = normalize( -splitSphere.xyz + positionWS );                                                                                                                        \
+		float  cascDot     = dot( cascadeDir, wposDir );                                                                                                                                        \
+        alpha = cascDot > 0.0 ? alpha : lerp( alpha, 0.0, saturate( -cascDot * 4.0 ) );                                                                                                         \
+                                                                                                                                                                                                \
+        /* get shadowmap texcoords */																																					        \
 		float3 posNDC;                                                                                                                                                                          \
 		float3 posTC = EvalShadow_GetTexcoords( sd, positionWS, posNDC, true );																											        \
 		/* sample the texture */																																						        \
 		float shadow = SampleShadow_SelectAlgorithm( shadowContext, sd, payloadOffset, posTC, sd.bias, slice, shadowAlgorithm, tex, samp );                                                     \
-																																																\
-		float border = borders[shadowSplitIndex];                                                                                                                                               \
-		float alpha  = border <= 0.0 ? 0.0 : saturate( (relDistance - (1.0 - border)) / border );                                                                                               \
-			float4 splitSphere = dirShadowSplitSpheres[shadowSplitIndex - 1];                                                                                                                   \
-			float3 cascadeDir  = normalize( -splitSphere.xyz + dirShadowSplitSpheres[shadowSplitIndex].xyz );                                                                                   \
-			float3 wposDir     = normalize( -splitSphere.xyz + positionWS );                                                                                                                    \
-			float  cascDot     = dot( cascadeDir, wposDir );                                                                                                                                    \
-			alpha   = cascDot > 0.0 ? alpha : lerp( alpha, 0.0, saturate( -cascDot * 4.0 ) );                                                                                                   \
 			shadow1 = shadow;                                                                                                                                                                   \
 																																																\
 			[branch]                                                                                                                                                                            \

ScriptableRenderPipeline/Core/Shadow/Shadow.cs

 
         override public void Update( FrameId frameId, ScriptableRenderContext renderContext, CommandBuffer cmd, CullResults cullResults, List<VisibleLight> lights)
         {
+            if (m_ActiveEntriesCount == 0)
+                return;
+
             var profilingSample = new HDPipeline.Utilities.ProfilingSample(string.Format("Shadowmap{0}",m_TexSlot), cmd);
 
             string cbName = "";
                     cmd.EndSample(cbName);
                 }
 
-                cbName = string.Format("Shadowmap.Update - slice: {0}, vp.x: {1}, vp.y: {2}, vp.w: {3}, vp.h: {4}", curSlice, m_EntryCache[i].current.viewport.x, m_EntryCache[i].current.viewport.y, m_EntryCache[i].current.viewport.width, m_EntryCache[i].current.viewport.height);
-                cmd.BeginSample(cbName);
+                //cbName = string.Format("Shadowmap.Update - slice: {0}, vp.x: {1}, vp.y: {2}, vp.w: {3}, vp.h: {4}", curSlice, m_EntryCache[i].current.viewport.x, m_EntryCache[i].current.viewport.y, m_EntryCache[i].current.viewport.width, m_EntryCache[i].current.viewport.height);
+                //cmd.BeginSample(cbName);
-                cmd.EndSample(cbName);
+                //cmd.EndSample(cbName);
 
                 dss.lightIndex = m_EntryCache[i].key.visibleIdx;
                 dss.splitData = m_EntryCache[i].current.splitData;
 
         public override void RenderShadows( FrameId frameId, ScriptableRenderContext renderContext, CommandBuffer cmd, CullResults cullResults, List<VisibleLight> lights)
         {
-            using (new HDPipeline.Utilities.ProfilingSample("Render Shadows Exp", cmd))
+            using (new HDPipeline.Utilities.ProfilingSample("Render Shadows", cmd))
             {
                 foreach( var sm in m_Shadowmaps )
                 {

ScriptableRenderPipeline/HDRenderPipeline/Debug/DebugDisplay.cs

         MinLightingFullScreenDebug, 
         SSAO,
         SSAOBeforeFiltering,
+        DeferredShadows,
         MaxLightingFullScreenDebug,
 
         // Rendering

ScriptableRenderPipeline/HDRenderPipeline/Debug/DebugDisplay.cs.hlsl

 //
-// This file was automatically generated from Assets/ScriptableRenderPipeline/HDRenderPipeline/Debug/DebugDisplay.cs.  Please don't edit by hand.
+// This file was automatically generated from Assets/ScriptableRenderLoop/ScriptableRenderPipeline/HDRenderPipeline/Debug/DebugDisplay.cs.  Please don't edit by hand.
 //
 
 #ifndef DEBUGDISPLAY_CS_HLSL
 #define FULLSCREENDEBUGMODE_MIN_LIGHTING_FULL_SCREEN_DEBUG (1)
 #define FULLSCREENDEBUGMODE_SSAO (2)
 #define FULLSCREENDEBUGMODE_SSAOBEFORE_FILTERING (3)
-#define FULLSCREENDEBUGMODE_MAX_LIGHTING_FULL_SCREEN_DEBUG (4)
-#define FULLSCREENDEBUGMODE_MIN_RENDERING_FULL_SCREEN_DEBUG (5)
-#define FULLSCREENDEBUGMODE_MOTION_VECTORS (6)
-#define FULLSCREENDEBUGMODE_NAN_TRACKER (7)
-#define FULLSCREENDEBUGMODE_MAX_RENDERING_FULL_SCREEN_DEBUG (8)
+#define FULLSCREENDEBUGMODE_DEFERRED_SHADOWS (4)
+#define FULLSCREENDEBUGMODE_MAX_LIGHTING_FULL_SCREEN_DEBUG (5)
+#define FULLSCREENDEBUGMODE_MIN_RENDERING_FULL_SCREEN_DEBUG (6)
+#define FULLSCREENDEBUGMODE_MOTION_VECTORS (7)
+#define FULLSCREENDEBUGMODE_NAN_TRACKER (8)
+#define FULLSCREENDEBUGMODE_MAX_RENDERING_FULL_SCREEN_DEBUG (9)
 
 
 #endif

ScriptableRenderPipeline/HDRenderPipeline/Debug/DebugFullScreen.shader

 
                     return float4(color + d.xxx, 1.0);
                 }
+                if (_FullScreenDebugMode == FULLSCREENDEBUGMODE_DEFERRED_SHADOWS)
+                {
+                    float4 color = SAMPLE_TEXTURE2D(_DebugFullScreenTexture, sampler_DebugFullScreenTexture, input.texcoord);
+                    return float4(color.rgb, 0.0);
+                }
 
                 return float4(0.0, 0.0, 0.0, 0.0);
             }

ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipeline.cs

         private RenderTexture m_CameraDepthBufferCopy = null;
         private RenderTexture m_CameraStencilBufferCopy = null;
         private RenderTexture m_HTile = null;                   // If the hardware does not expose it, we compute our own, optimized to only contain the SSS bit
+        private RenderTexture m_DeferredDirShadow = null;
+        private RenderTargetIdentifier m_DeferredDirShadowRT;
         
         // Post-processing context and screen-space effects (recycled on every frame to avoid GC alloc)
         readonly PostProcessRenderContext m_PostProcessContext;
                 m_HTile.Create();
                 m_HTileRT = new RenderTargetIdentifier(m_HTile);
             }
+
+            m_DeferredDirShadow = new RenderTexture(camera.pixelWidth, camera.pixelHeight, 0, RenderTextureFormat.ARGB32, RenderTextureReadWrite.Linear);
+            m_DeferredDirShadow.filterMode = FilterMode.Point;
+            m_DeferredDirShadow.enableRandomWrite = true;
+            m_DeferredDirShadow.Create();
+            m_DeferredDirShadowRT = new RenderTargetIdentifier(m_DeferredDirShadow);
         }
 
         void Resize(Camera camera)
                     // TODO: Everything here (SSAO, Shadow, Build light list, material and light classification can be parallelize with Async compute)
                     m_SsaoEffect.Render(ssaoSettingsToUse, this, hdCamera, renderContext, cmd, m_Asset.renderingSettings.useForwardRenderingOnly);
                     m_LightLoop.PrepareLightsForGPU(m_ShadowSettings, m_CullResults, camera);
-                    m_LightLoop.RenderShadows(renderContext, cmd, m_CullResults);
+                    m_LightLoop.RenderShadows(renderContext, cmd, m_CullResults);  
+
+                    m_LightLoop.RenderDeferredDirectionalShadow(hdCamera, m_DeferredDirShadowRT, GetDepthTexture(), cmd);
+
+                    PushFullScreenDebugTexture(cmd, m_DeferredDirShadowRT, hdCamera.camera, renderContext, FullScreenDebugMode.DeferredShadows);
+
                     renderContext.SetupCameraProperties(camera); // Need to recall SetupCameraProperties after m_ShadowPass.Render
                     m_LightLoop.BuildGPULightLists(camera, cmd, m_CameraDepthStencilBufferRT, GetStencilTexture());
                 }
                 // Output split lighting for materials asking for it (masked in the stencil buffer)
                 options.outputSplitLighting = true;
 
-                m_LightLoop.RenderDeferredLighting(hdCamera, cmd, m_DebugDisplaySettings, colorRTs, m_CameraDepthStencilBufferRT, depthTexture, options);
+                m_LightLoop.RenderDeferredLighting(hdCamera, cmd, m_DebugDisplaySettings, colorRTs, m_CameraDepthStencilBufferRT, depthTexture, m_DeferredDirShadowRT,options);
-            m_LightLoop.RenderDeferredLighting(hdCamera, cmd, m_DebugDisplaySettings, colorRTs, m_CameraDepthStencilBufferRT, depthTexture, options);
+            m_LightLoop.RenderDeferredLighting(hdCamera, cmd, m_DebugDisplaySettings, colorRTs, m_CameraDepthStencilBufferRT, depthTexture, m_DeferredDirShadowRT, options);
         }
 
         // Combines specular lighting and diffuse lighting with subsurface scattering.
             Shader.SetGlobalVector(HDShaderIDs._DebugLightingSmoothness, debugSmoothness);
         }
 
-        public void PushFullScreenDebugTexture(CommandBuffer cb, int textureID, Camera camera, ScriptableRenderContext renderContext, FullScreenDebugMode debugMode)
+        public void PushFullScreenDebugTexture(CommandBuffer cb, RenderTargetIdentifier textureID, Camera camera, ScriptableRenderContext renderContext, FullScreenDebugMode debugMode)
-            if(debugMode == m_DebugDisplaySettings.fullScreenDebugMode)
+            if (debugMode == m_DebugDisplaySettings.fullScreenDebugMode)
+        }
+
+        public void PushFullScreenDebugTexture(CommandBuffer cb, int textureID, Camera camera, ScriptableRenderContext renderContext, FullScreenDebugMode debugMode)
+        {
+            PushFullScreenDebugTexture(cb, new RenderTargetIdentifier(textureID), camera, renderContext, debugMode);
         }
 
         void RenderDebug(HDCamera camera, CommandBuffer cmd)

ScriptableRenderPipeline/HDRenderPipeline/HDShaderIDs.cs

 
         internal static readonly int _MainDepthTexture = Shader.PropertyToID("_MainDepthTexture");
 
+        internal static readonly int _DeferredShadowTexture = Shader.PropertyToID("_DeferredShadowTexture");
+        internal static readonly int _DeferredShadowTextureUAV = Shader.PropertyToID("_DeferredShadowTextureUAV");
+        internal static readonly int _DirectionalShadowIndex = Shader.PropertyToID("_DirectionalShadowIndex");
+
         internal static readonly int unity_OrthoParams = Shader.PropertyToID("unity_OrthoParams");
         internal static readonly int _ZBufferParams = Shader.PropertyToID("_ZBufferParams");
         internal static readonly int _ScreenParams = Shader.PropertyToID("_ScreenParams");

ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/TilePass.cs

             private ComputeShader buildDispatchIndirectShader { get { return m_Resources.buildDispatchIndirectShader; } }
             private ComputeShader clearDispatchIndirectShader { get { return m_Resources.clearDispatchIndirectShader; } }
             private ComputeShader deferredComputeShader { get { return m_Resources.deferredComputeShader; } }
+            private ComputeShader deferredDirectionalShadowComputeShader { get { return m_Resources.deferredDirectionalShadowComputeShader; } }
+
 
             static int s_GenAABBKernel;
             static int s_GenListPerTileKernel;
             // Tag: SUPPORT_COMPUTE_CLUSTER_OPAQUE - Uncomment this if you want to do cluster opaque with compute shader (by default we support only fptl on opaque)
             //static int[] s_shadeOpaqueIndirectClusteredKernels = new int[LightDefinitions.s_NumFeatureVariants];
             static int[] s_shadeOpaqueIndirectFptlKernels = new int[LightDefinitions.s_NumFeatureVariants];
+
+            static int s_deferredDirectionalShadowKernel;
 
             static ComputeBuffer s_LightVolumeDataBuffer = null;
             static ComputeBuffer s_ConvexBoundsBuffer = null;
             Material m_SingleDeferredMaterialMRT   = null;
 
             Light m_CurrentSunLight = null;
+            int m_CurrentSunLightShadowIndex = -1;
+
             public Light GetCurrentSunLight() { return m_CurrentSunLight; }
 
             // shadow related stuff
                 s_shadeOpaqueDirectClusteredDebugDisplayKernel = deferredComputeShader.FindKernel("Deferred_Direct_Clustered_DebugDisplay");
                 s_shadeOpaqueDirectFptlDebugDisplayKernel = deferredComputeShader.FindKernel("Deferred_Direct_Fptl_DebugDisplay");
 
+                s_deferredDirectionalShadowKernel = deferredDirectionalShadowComputeShader.FindKernel("DeferredDirectionalShadow");
+
                 for (int variant = 0; variant < LightDefinitions.s_NumFeatureVariants; variant++)
                 {
                     // Tag: SUPPORT_CLUSTER_OPAQUE - Uncomment this if you want to do cluster opaque (by default we support only fptl on opaque)
                 {
                     directionalLightData.shadowIndex = shadowIdx;
                     m_CurrentSunLight = light.light;
+                    m_CurrentSunLightShadowIndex = shadowIdx;
                 }
                 m_CurrentSunLight = m_CurrentSunLight == null ? light.light : m_CurrentSunLight;
 
                     // The lightLoop is in charge, not the shadow pass.
                     // For now we will still apply the maximum of shadow here but we don't apply the sorting by priority + slot allocation yet
                     m_CurrentSunLight = null;
+                    m_CurrentSunLightShadowIndex = -1;
 
                     // 2. Go through all lights, convert them to GPU format.
                     // Create simultaneously data for culling (LigthVolumeData and rendering)
 
             public void BuildGPULightLists(Camera camera, CommandBuffer cmd, RenderTargetIdentifier cameraDepthBufferRT, RenderTargetIdentifier stencilTextureRT)
             {
+                cmd.BeginSample("Build Light List");
+
                 var w = camera.pixelWidth;
                 var h = camera.pixelHeight;
                 var numBigTilesX = (w + 63) / 64;
                     cmd.SetComputeIntParam(buildDispatchIndirectShader, HDShaderIDs.g_NumTilesX, numTilesX);
                     cmd.DispatchCompute(buildDispatchIndirectShader, s_BuildDispatchIndirectKernel, (numTiles + 63) / 64, 1, 1);
                 }
+
+                cmd.EndSample("Build Light List");
             }
 
             // This is a workaround for global properties not being accessible from compute.
                 public bool volumetricLightingEnabled;
             }
 
+            public void RenderDeferredDirectionalShadow(HDCamera hdCamera, RenderTargetIdentifier deferredShadowRT, RenderTargetIdentifier depthTexture, CommandBuffer cmd)
+            {
+                if (m_CurrentSunLight == null)
+                    return;
+
+                using (new Utilities.ProfilingSample("Deferred Directional", cmd))
+                {
+                    hdCamera.SetupComputeShader(deferredDirectionalShadowComputeShader, cmd);
+                    m_ShadowMgr.BindResources(cmd, deferredDirectionalShadowComputeShader, s_deferredDirectionalShadowKernel);
+
+                    cmd.SetComputeFloatParam(deferredDirectionalShadowComputeShader, HDShaderIDs._DirectionalShadowIndex, (float)m_CurrentSunLightShadowIndex);
+                    cmd.SetComputeTextureParam(deferredDirectionalShadowComputeShader, s_deferredDirectionalShadowKernel, HDShaderIDs._DeferredShadowTextureUAV, deferredShadowRT);
+                    cmd.SetComputeTextureParam(deferredDirectionalShadowComputeShader, s_deferredDirectionalShadowKernel, HDShaderIDs._MainDepthTexture, depthTexture);
+
+                    int deferredShadowTileSize = 16; // Must match DeferreDirectionalShadow.compute
+                    int numTilesX = (hdCamera.camera.pixelWidth + (deferredShadowTileSize - 1)) / deferredShadowTileSize;
+                    int numTilesY = (hdCamera.camera.pixelHeight + (deferredShadowTileSize - 1)) / deferredShadowTileSize;
+
+                    cmd.DispatchCompute(deferredDirectionalShadowComputeShader, s_deferredDirectionalShadowKernel, numTilesX, numTilesY, 1);
+                }
+            }
+
-                                                RenderTargetIdentifier[] colorBuffers, RenderTargetIdentifier depthStencilBuffer, RenderTargetIdentifier depthTexture,
+                                                RenderTargetIdentifier[] colorBuffers, RenderTargetIdentifier depthStencilBuffer, RenderTargetIdentifier depthTexture, RenderTargetIdentifier deferredShadowTexture,
                                                 LightingPassOptions options)
             {
                 var bUseClusteredForDeferred = !usingFptl;
                             Texture ltcGGXMatrix = Shader.GetGlobalTexture(HDShaderIDs._LtcGGXMatrix);
                             Texture ltcDisneyDiffuseMatrix = Shader.GetGlobalTexture(HDShaderIDs._LtcDisneyDiffuseMatrix);
                             Texture ltcMultiGGXFresnelDisneyDiffuse = Shader.GetGlobalTexture(HDShaderIDs._LtcMultiGGXFresnelDisneyDiffuse);
-                            Texture gBufferTexture0 = Shader.GetGlobalTexture(HDShaderIDs._GBufferTexture0);
-                            Texture gBufferTexture1 = Shader.GetGlobalTexture(HDShaderIDs._GBufferTexture1);
-                            Texture gBufferTexture2 = Shader.GetGlobalTexture(HDShaderIDs._GBufferTexture2);
-                            Texture gBufferTexture3 = Shader.GetGlobalTexture(HDShaderIDs._GBufferTexture3);
-                            Texture ambientOcclusionTexture = Shader.GetGlobalTexture(HDShaderIDs._AmbientOcclusionTexture);
 
                             Matrix4x4 invScrProjection = Shader.GetGlobalMatrix(HDShaderIDs.g_mInvScrProjection);
                             int useTileLightList = Shader.GetGlobalInt(HDShaderIDs._UseTileLightList);
 
                                 cmd.SetComputeBufferParam(deferredComputeShader, kernel, HDShaderIDs.g_vLightListGlobal, bUseClusteredForDeferred ? s_PerVoxelLightLists : s_LightList);
 
+                                cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs._DeferredShadowTexture, deferredShadowTexture);
+
-                                cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs._GBufferTexture0, gBufferTexture0);
-                                cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs._GBufferTexture1, gBufferTexture1);
-                                cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs._GBufferTexture2, gBufferTexture2);
-                                cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs._GBufferTexture3, gBufferTexture3);
-                                cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs._AmbientOcclusionTexture, ambientOcclusionTexture);
+                                cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs._GBufferTexture1, HDShaderIDs._GBufferTexture1);
+                                cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs._GBufferTexture0, HDShaderIDs._GBufferTexture0);
+                                cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs._GBufferTexture2, HDShaderIDs._GBufferTexture2);
+                                cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs._GBufferTexture3, HDShaderIDs._GBufferTexture3);
+                                cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs._AmbientOcclusionTexture, HDShaderIDs._AmbientOcclusionTexture);
 
                                 cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs._LtcData, ltcData);
                                 cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs._PreIntegratedFGD, preIntegratedFGD);

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.hlsl

 
     [branch] if (lightData.shadowIndex >= 0)
     {
-        shadow = GetDirectionalShadowAttenuation(lightLoopContext.shadowContext, positionWS, bsdfData.normalWS, lightData.shadowIndex, L, posInput.unPositionSS);
+        shadow = LOAD_TEXTURE2D(_DeferredShadowTexture, posInput.unPositionSS).x;
         illuminance *= shadow;
     }
 

ScriptableRenderPipeline/HDRenderPipeline/RenderPipelineResources/HDRenderPipelineResources.asset

     type: 3}
   deferredComputeShader: {fileID: 7200000, guid: 0b64f79746d2daf4198eaf6eab9af259,
     type: 3}
+  deferredDirectionalShadowComputeShader: {fileID: 7200000, guid: fbde6fae193b2a94e9fd97c163c204f4,
+    type: 3}
   cameraMotionVectors: {fileID: 4800000, guid: 035941b63024d1943af48811c1db20d9, type: 3}
   blitCubemap: {fileID: 4800000, guid: d05913e251bed7a4992c921c62e1b647, type: 3}
   buildProbabilityTables: {fileID: 7200000, guid: b9f26cf340afe9145a699753531b2a4c,

ScriptableRenderPipeline/HDRenderPipeline/RenderPipelineResources/RenderPipelineResources.cs

             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.deferredComputeShader = UnityEditor.AssetDatabase.LoadAssetAtPath<ComputeShader>("Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/Deferred.compute");
+            instance.deferredDirectionalShadowComputeShader = UnityEditor.AssetDatabase.LoadAssetAtPath<ComputeShader>("Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/DeferredDirectionalShadow.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 buildPerVoxelLightListShader;    // clustered
         public ComputeShader buildMaterialFlagsShader;
         public ComputeShader deferredComputeShader;
+        public ComputeShader deferredDirectionalShadowComputeShader;
 
         // SceneSettings
         // These shaders don't need to be reference by RenderPipelineResource as they are not use at runtime (only to draw in editor)

ScriptableRenderPipeline/HDRenderPipeline/ShaderVariables.hlsl

 TEXTURE2D_FLOAT(_MainDepthTexture);
 SAMPLER2D(sampler_MainDepthTexture);
 
+TEXTURE2D(_DeferredShadowTexture);
+
 // Main lightmap
 TEXTURE2D(unity_Lightmap);
 SAMPLER2D(samplerunity_Lightmap);

SampleScenes/HDTest/ShadowsTest.meta

+fileFormatVersion: 2
+guid: 37b64947bf0ad024fb931d24f17a52b7
+folderAsset: yes
+timeCreated: 1504864302
+licenseType: Pro
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/DeferredDirectionalShadow.compute

+// Each #kernel tells which function to compile; you can have many kernels
+#pragma kernel DeferredDirectionalShadow
+
+#include "../../../Core/ShaderLibrary/Common.hlsl"
+#include "../../ShaderVariables.hlsl"
+#include "../../Lighting/Lighting.hlsl" 
+
+RWTexture2D<float4> _DeferredShadowTextureUAV;
+float               _DirectionalShadowIndex;
+
+#define DEFERRED_SHADOW_TILE_SIZE 16
+
+[numthreads(DEFERRED_SHADOW_TILE_SIZE, DEFERRED_SHADOW_TILE_SIZE, 1)]
+void DeferredDirectionalShadow(uint2 groupThreadId : SV_GroupThreadID, uint2 groupId : SV_GroupID)
+{
+    uint2 pixelCoord = groupId * DEFERRED_SHADOW_TILE_SIZE + groupThreadId;
+    uint2 tileCoord = groupId;
+
+    PositionInputs posInput = GetPositionInput(pixelCoord.xy, _ScreenSize.zw, tileCoord);
+
+    float depth = LOAD_TEXTURE2D(_MainDepthTexture, posInput.unPositionSS).x;
+    UpdatePositionInput(depth, _InvViewProjMatrix, _ViewProjMatrix, posInput);
+
+    ShadowContext shadowContext = InitShadowContext();
+    float shadow = GetDirectionalShadowAttenuation(shadowContext, posInput.positionWS, float3(0.0, 0.0, 0.0), (uint)_DirectionalShadowIndex, float3(0.0, 0.0, 0.0));
+
+    _DeferredShadowTextureUAV[pixelCoord] = float4(shadow.xxx, 0.0);
+}

ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/DeferredDirectionalShadow.compute.meta

+fileFormatVersion: 2
+guid: fbde6fae193b2a94e9fd97c163c204f4
+timeCreated: 1505129983
+licenseType: Pro
+ComputeShaderImporter:
+  externalObjects: {}
+  currentAPIMask: 8196
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: