View space position reconstruction

ScriptableRenderPipeline/LightweightPipeline/LWRP/LightweightPipeline.cs

         private const int kMaxCascades = 4;
         private int m_ShadowCasterCascadesCount;
         private int m_ShadowMapRTID;
+        private int m_ScreenSpaceShadowMapRTID;
+        private RenderTargetIdentifier m_ScreenSpaceShadowMapRT;
         private RenderTargetIdentifier m_ColorRT;
         private RenderTargetIdentifier m_CopyColorRT;
         private RenderTargetIdentifier m_DepthRT;
         private Material m_BlitMaterial;
         private Material m_CopyDepthMaterial;
         private Material m_ErrorMaterial;
+        private Material m_ScreenSpaceShadowsMaterial;
         private int m_BlitTexID = Shader.PropertyToID("_BlitTex");
 
         private CopyTextureSupport m_CopyTextureSupport;
             PerCameraBuffer._AdditionalLightSpotAttenuation = Shader.PropertyToID("_AdditionalLightSpotAttenuation");
 
             m_ShadowMapRTID = Shader.PropertyToID("_ShadowMap");
+            m_ScreenSpaceShadowMapRTID = Shader.PropertyToID("_ScreenSpaceShadowMap");
 
             CameraRenderTargetID.color = Shader.PropertyToID("_CameraColorRT");
             CameraRenderTargetID.copyColor = Shader.PropertyToID("_CameraCopyColorRT");
             m_ShadowMapRT = new RenderTargetIdentifier(m_ShadowMapRTID);
+            m_ScreenSpaceShadowMapRT = new RenderTargetIdentifier(m_ScreenSpaceShadowMapRTID);
 
             m_ColorRT = new RenderTargetIdentifier(CameraRenderTargetID.color);
             m_CopyColorRT = new RenderTargetIdentifier(CameraRenderTargetID.copyColor);
             m_BlitMaterial = CoreUtils.CreateEngineMaterial(m_Asset.BlitShader);
             m_CopyDepthMaterial = CoreUtils.CreateEngineMaterial(m_Asset.CopyDepthShader);
             m_ErrorMaterial = CoreUtils.CreateEngineMaterial("Hidden/InternalErrorShader");
+            m_ScreenSpaceShadowsMaterial = CoreUtils.CreateEngineMaterial("Hidden/LightweightPipeline/ScreenSpaceShadows");
         }
 
         public override void Dispose()
 
                 if (LightweightUtils.HasFlag(frameRenderingConfiguration, FrameRenderingConfiguration.DepthPrePass))
                     DepthPass(ref context);
+
+                //TODO: Shadow Gather Here
+                //NOTE: Enable Depth PrePass flag based on SS Shadow Checkbox and then check for that again here?
+                CollectShadowPass(ref context);
+
                 ForwardPass(visibleLights, frameRenderingConfiguration, ref context, ref lightData, stereoEnabled);
 
                 // Release temporary RT
             };
 
             context.DrawRenderers(m_CullResults.visibleRenderers, ref opaqueDrawSettings, opaqueFilterSettings);
+        }
+
+        private Vector4[] GetFarPlaneCorners()
+        {
+            Vector4[] corners = new Vector4[4];
+
+            //http://www.lighthouse3d.com/tutorials/view-frustum-culling/geometric-approach-extracting-the-planes/
+            float farH   = 2.0f * Mathf.Tan(m_CurrCamera.fieldOfView * 0.5f * Mathf.Deg2Rad) * m_CurrCamera.farClipPlane;
+            float farW   = farH * m_CurrCamera.aspect;
+            
+            Vector3 fc    = Vector3.forward * m_CurrCamera.farClipPlane;
+            Vector3 up    = Vector3.up; 
+            Vector3 right = Vector3.right; 
+
+            corners[0] = fc - (up * farH / 2) - (right * farW / 2);
+            corners[1] = fc + (up * farH / 2) - (right * farW / 2);
+            corners[2] = fc + (up * farH / 2) + (right * farW / 2);
+            corners[3] = fc - (up * farH / 2) + (right * farW / 2);
+
+            return corners;
+        }
+
+        private void CollectShadowPass(ref ScriptableRenderContext context)
+        {
+            CommandBuffer cmd = CommandBufferPool.Get("Collect Shadows");
+            //NOTE: Renderscale?
+            cmd.GetTemporaryRT(m_ScreenSpaceShadowMapRTID, m_CurrCamera.pixelWidth, m_CurrCamera.pixelHeight, 0, FilterMode.Bilinear, RenderTextureFormat.ARGB32);
+            
+            //TODO: Fullscreen triangle?
+            //SetRenderTarget(cmd, m_ScreenSpaceShadowMapRT, ClearFlag.Color); //NOTE: Clear Depth?
+
+            cmd.SetGlobalTexture("_Depth", m_DepthRT);
+            cmd.SetGlobalTexture("_ShadowCascades", m_ShadowMapRT);
+            cmd.SetGlobalVectorArray("_FrustumCorners", GetFarPlaneCorners());
+            cmd.Blit(null, m_ScreenSpaceShadowMapRT, m_ScreenSpaceShadowsMaterial); //TODO: PCF passes
+
+            context.ExecuteCommandBuffer(cmd);
+            CommandBufferPool.Release(cmd);
         }
 
         private void ForwardPass(List<VisibleLight> visibleLights, FrameRenderingConfiguration frameRenderingConfiguration, ref ScriptableRenderContext context, ref LightData lightData, bool stereoEnabled)

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/CoreFunctions.hlsl

 #endif
 }
 
+float3 TransformObjectToView(float3 positionOS)
+{
+    return mul(GetWorldToViewMatrix(), mul(GetObjectToWorldMatrix(), float4(positionOS, 1.0))).xyz;
+}
+
 // Transforms position from object space to homogenous space
 float4 TransformObjectToHClip(float3 positionWS)
 {

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightScreenSpaceShadows.shader

+Shader "Hidden/LightweightPipeline/ScreenSpaceShadows"
+{
+    SubShader
+    {
+        Tags {}
+
+        Pass
+        {
+            ZTest Always ZWrite Off
+
+            HLSLPROGRAM
+            #pragma vertex   Vertex
+            #pragma fragment Fragment
+
+            #include "LWRP/ShaderLibrary/Core.hlsl"
+
+            //Scene Depth
+            TEXTURE2D(_Depth);
+            SAMPLER(sampler_Depth);
+
+            //Shadow Cascades
+            TEXTURE2D(_ShadowCascades);
+            SAMPLER(sampler_ShadowCascades);
+
+            //Far plane corners in view space
+            float4 _FrustumCorners[4];
+
+            struct VertexInput
+            {
+                float4 vertex : POSITION;
+                float2 uv     : TEXCOORD0;
+                uint   id     : SV_VertexID;
+            };
+
+            struct VertexOutput
+            {
+                half4  pos    : SV_POSITION;
+                half2  uv     : TEXCOORD0;
+                float3 ray    : TEXCOORD1;
+            };
+
+            VertexOutput Vertex(VertexInput i)
+            {
+                VertexOutput o;
+                o.pos = TransformObjectToHClip(i.vertex.xyz);
+                o.uv  = i.uv;
+                o.ray = _FrustumCorners[i.id]; 
+                return o;
+            }
+
+            float3 ComputeViewSpacePosition(VertexOutput i)
+            {
+                float depth = SAMPLE_DEPTH_TEXTURE(_Depth, sampler_Depth, i.uv);
+                depth = Linear01Depth(depth, _ZBufferParams);
+
+                return i.ray * depth;
+            }
+
+            half4 Fragment(VertexOutput i) : SV_Target
+            {
+                return half4(ComputeViewSpacePosition(i), 1);
+            }
+
+            ENDHLSL
+        }
+    }
+}

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightScreenSpaceShadows.shader.meta

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