First part of relatime shadows refactor.

ScriptableRenderPipeline/LightweightPipeline/Data/LightweightPipelineAsset.cs

     {
         _512 = 512,
         _1024 = 1024,
-        _2048 = 2048
+        _2048 = 2048,
+        _4096 = 4096
     }
 
     public enum MSAAQuality
         [SerializeField] private MSAAQuality m_MSAA = MSAAQuality._4x;
         [SerializeField] private float m_RenderScale = 1.0f;
         [SerializeField] private ShadowType m_ShadowType = ShadowType.HARD_SHADOWS;
-        [SerializeField] private ShadowResolution m_ShadowAtlasResolution = ShadowResolution._1024;
+        [SerializeField] private ShadowResolution m_ShadowAtlasResolution = ShadowResolution._2048;
-        [SerializeField] private ShadowCascades m_ShadowCascades = ShadowCascades.NO_CASCADES;
+        [SerializeField] private ShadowCascades m_ShadowCascades = ShadowCascades.FOUR_CASCADES;
         [SerializeField] private float m_Cascade2Split = 0.25f;
         [SerializeField] private Vector3 m_Cascade4Split = new Vector3(0.067f, 0.2f, 0.467f);
 

ScriptableRenderPipeline/LightweightPipeline/LightweightPipeline.cs

         public Vector3  directionalLightCascades;
         public float    directionalLightNearPlaneOffset;
 
+        public RenderTextureFormat renderTextureFormat;
+
         static ShadowSettings defaultShadowSettings = null;
 
         public static ShadowSettings Default
                     defaultShadowSettings.directionalLightCascadeCount = 4;
                     defaultShadowSettings.directionalLightNearPlaneOffset = 5;
                     defaultShadowSettings.maxShadowDistance = 1000.0F;
+                    defaultShadowSettings.renderTextureFormat = RenderTextureFormat.Shadowmap;
                 }
                 return defaultShadowSettings;
             }
             m_ShadowSettings.shadowAtlasWidth = m_Asset.ShadowAtlasResolution;
             m_ShadowSettings.shadowAtlasHeight = m_Asset.ShadowAtlasResolution;
             m_ShadowSettings.maxShadowDistance = m_Asset.ShadowDistance;
+            m_ShadowSettings.renderTextureFormat = SystemInfo.SupportsRenderTextureFormat(RenderTextureFormat.Shadowmap)
+                ? RenderTextureFormat.Shadowmap
+                : RenderTextureFormat.Depth;
 
             switch (m_ShadowSettings.directionalLightCascadeCount)
             {
             for (int i = 0; i < cascadeCount; ++i)
                 shadowMatrices[i] = (cascadeCount >= i) ? m_ShadowSlices[i].shadowTransform : Matrix4x4.identity;
 
-            // TODO: shadow resolution per cascade in case cascades endup being supported.
-            float invShadowResolution = 1.0f / shadowResolution;
-            float[] pcfKernel =
-            {
-                -0.5f * invShadowResolution, 0.5f * invShadowResolution,
-                0.5f * invShadowResolution, 0.5f * invShadowResolution,
-                -0.5f * invShadowResolution, -0.5f * invShadowResolution,
-                0.5f * invShadowResolution, -0.5f * invShadowResolution
-            };
-
+            float invShadowResolution = 0.5f / shadowResolution;
-            cmd.SetGlobalFloatArray("_PCFKernel", pcfKernel);
+            cmd.SetGlobalVector("_ShadowOffset0", new Vector4(-invShadowResolution, -invShadowResolution, 0.0f, 0.0f));
+            cmd.SetGlobalVector("_ShadowOffset1", new Vector4( invShadowResolution, -invShadowResolution, 0.0f, 0.0f));
+            cmd.SetGlobalVector("_ShadowOffset2", new Vector4(-invShadowResolution,  invShadowResolution, 0.0f, 0.0f));
+            cmd.SetGlobalVector("_ShadowOffset3", new Vector4( invShadowResolution,  invShadowResolution, 0.0f, 0.0f));
         }
 
         private void SetShaderKeywords(CommandBuffer cmd, ref LightData lightData, VisibleLight[] visibleLights)
             var cmd = CommandBufferPool.Get();
             cmd.name = "Render packed shadows";
             cmd.GetTemporaryRT(m_ShadowMapRTID, m_ShadowSettings.shadowAtlasWidth,
-                m_ShadowSettings.shadowAtlasHeight, kShadowDepthBufferBits, FilterMode.Bilinear, RenderTextureFormat.Depth);
+                m_ShadowSettings.shadowAtlasHeight, kShadowDepthBufferBits, FilterMode.Bilinear, m_ShadowSettings.renderTextureFormat);
             SetRenderTarget(cmd, m_ShadowMapRT, ClearFlag.All);
             context.ExecuteCommandBuffer(cmd);
             CommandBufferPool.Release(cmd);
                 if (m_RequiredDepth && !LightweightUtils.HasFlag(renderingConfig, FrameRenderingConfiguration.DepthPass))
                     depthRT = m_DepthRT;
             }
-
 
             if (ForceClear())
             {

ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightShadows.cginc

 #define LIGHTWEIGHT_SHADOW_ATTENUATION(posWorld, vertexNormal, shadowDir) 1.0h
 #endif
 
-sampler2D_float _ShadowMap;
-float _PCFKernel[8];
+UNITY_DECLARE_SHADOWMAP(_ShadowMap);
-half4 _ShadowData;
+half4 _ShadowOffset0;
+half4 _ShadowOffset1;
+half4 _ShadowOffset2;
+half4 _ShadowOffset3;
+half4 _ShadowData; // (x: 1.0 - shadowStrength, y: bias, z: normal bias, w: near plane offset)
+
+float ApplyDepthBias(float clipZ)
+{
+#ifdef UNITY_REVERSED_Z
+    return  clipZ + _ShadowData.y;
+#endif
+
+    return  clipZ - _ShadowData.y;
+}
-inline half ShadowAttenuation(float3 shadowCoord)
+inline half SampleShadowmap(float4 shadowCoord)
-    float depth = tex2D(_ShadowMap, shadowCoord).r;
-
-#if defined(UNITY_REVERSED_Z)
-    return step(depth - _ShadowData.y, shadowCoord.z);
+#if defined(_SOFT_SHADOWS) || defined(_SOFT_SHADOWS_CASCADES)
+    // 4-tap hardware comparison
+    float3 coord = shadowCoord.xyz /= shadowCoord.w;
+    coord.z = ApplyDepthBias(coord.z);
+    half4 attenuation;
+    attenuation.x = UNITY_SAMPLE_SHADOW(_ShadowMap, coord + _ShadowOffset0.xyz);
+    attenuation.y = UNITY_SAMPLE_SHADOW(_ShadowMap, coord + _ShadowOffset1.xyz);
+    attenuation.z = UNITY_SAMPLE_SHADOW(_ShadowMap, coord + _ShadowOffset2.xyz);
+    attenuation.w = UNITY_SAMPLE_SHADOW(_ShadowMap, coord + _ShadowOffset3.xyz);
+    lerp(attenuation, 1.0, _ShadowData.xxxx);
+    return dot(attenuation, 0.25);
-    return step(shadowCoord.z, depth + _ShadowData.y);
+    // 1-tap hardware comparison
+    shadowCoord.z = ApplyDepthBias(shadowCoord.z);
+    half attenuation = UNITY_SAMPLE_SHADOW_PROJ(_ShadowMap, shadowCoord);
+    return lerp(attenuation, 1.0, _ShadowData.x);
 #endif
 }
 
     return 4 - dot(weights, fixed4(4, 3, 2, 1));
 }
 
-inline half ShadowPCF(half3 shadowCoord)
-{
-    // TODO: simulate textureGatherOffset not available, simulate it
-    half2 offset = half2(0, 0);
-    half attenuation = ShadowAttenuation(half3(shadowCoord.xy + half2(_PCFKernel[0], _PCFKernel[1]) + offset, shadowCoord.z)) +
-        ShadowAttenuation(half3(shadowCoord.xy + half2(_PCFKernel[2], _PCFKernel[3]) + offset, shadowCoord.z)) +
-        ShadowAttenuation(half3(shadowCoord.xy + half2(_PCFKernel[4], _PCFKernel[5]) + offset, shadowCoord.z)) +
-        ShadowAttenuation(half3(shadowCoord.xy + half2(_PCFKernel[6], _PCFKernel[7]) + offset, shadowCoord.z));
-    return attenuation * 0.25;
-}
-
 inline half ComputeShadowAttenuation(float3 posWorld, half3 vertexNormal, half3 shadowDir)
 {
     half NdotL = dot(vertexNormal, shadowDir);
     if (cascadeIndex >= MAX_SHADOW_CASCADES)
         return 1.0;
 #endif
+
-    shadowCoord.xyz /= shadowCoord.w;
-    shadowCoord.z = saturate(shadowCoord.z);
-
-#if defined(_SOFT_SHADOWS) || defined(_SOFT_SHADOWS_CASCADES)
-    return ShadowPCF(shadowCoord.xyz);
-#else
-    return ShadowAttenuation(shadowCoord.xyz);
-#endif
+    return SampleShadowmap(shadowCoord);
 }
 
 half MixRealtimeAndBakedOcclusion(half realtimeAttenuation, half4 bakedOcclusion, half4 distanceAttenuation)

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/LightweightPipelineAsset.asset

   m_EditorClassIdentifier: 
   m_MaxPixelLights: 4
   m_SupportsVertexLight: 0
-  m_SupportSoftParticles: 0
+  m_RequireCameraDepthTexture: 0
-  m_ShadowAtlasResolution: 1024
+  m_ShadowAtlasResolution: 2048
-  m_ShadowCascades: 1
+  m_ShadowCascades: 4
+  m_DefaultShader: {fileID: 4800000, guid: 933532a4fcc9baf4fa0491de14d08ed7, type: 3}
+  m_BlitShader: {fileID: 4800000, guid: c17132b1f77d20942aa75f8429c0f8bc, type: 3}
+  m_CopyDepthShader: {fileID: 4800000, guid: d6dae50ee9e1bfa4db75f19f99355220, type: 3}
-  m_DefaultShader: {fileID: 4800000, guid: 933532a4fcc9baf4fa0491de14d08ed7, type: 3}
-  m_BlitShader: {fileID: 4800000, guid: c17132b1f77d20942aa75f8429c0f8bc, type: 3}
-  m_CopyDepthShader: {fileID: 4800000, guid: d6dae50ee9e1bfa4db75f19f99355220, type: 3}