URP unlit shadow

Shader "Universal Render Pipeline/Custom/Unlit Shadow"
{
    Properties
    {
        _BaseMap ("Texture", 2D) = "white" {}
        _BaseColor ("Light Color", Color) = (1,1,1,1)
        _ShadowColor ("Shadow Color", Color) = (0.5,0.5,0.5,1)
    }
    SubShader
    {
        Tags{"LightMode" = "UniversalForward"}
        LOD 100

        Pass
        {
            HLSLPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #pragma multi_compile_fog

            #pragma prefer_hlslcc gles
            #pragma exclude_renderers d3d11_9x

            #pragma target 3.0

            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"

            #pragma multi_compile _ _MAIN_LIGHT_SHADOWS
            #pragma multi_compile _ _MAIN_LIGHT_SHADOWS_CASCADE

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
                UNITY_VERTEX_INPUT_INSTANCE_ID
            };

            struct v2f
            {
                float2 uv : TEXCOORD0;
                float4 vertex : SV_POSITION;
                float4 positionWSAndFogFactor : TEXCOORD2; // xyz: positionWS, w: vertex fog factor
                float4 shadowCoord : TEXCOORD3;
            };

            sampler2D _BaseMap;

            CBUFFER_START(UnityPerMaterial)
            float4 _BaseMap_ST;
            half4 _BaseColor;
            half4 _ShadowColor;
            CBUFFER_END

            v2f vert (appdata v)
            {
                v2f o;
                VertexPositionInputs vertexInput = GetVertexPositionInputs(v.vertex.xyz);
                //VertexNormalInputs vertexNormalInput = GetVertexNormalInputs(input.normalOS, input.tangentOS);
                o.vertex = vertexInput.positionCS;

                float fogFactor = ComputeFogFactor(vertexInput.positionCS.z);
                o.positionWSAndFogFactor = float4(vertexInput.positionWS, fogFactor);

                o.shadowCoord = GetShadowCoord(vertexInput);

                o.uv = TRANSFORM_TEX(v.uv, _BaseMap);
                return o;
            }

            float4 frag (v2f i) : SV_Target
            {
                // sample the texture
                float4 color = tex2D(_BaseMap, i.uv);
                float fogFactor = i.positionWSAndFogFactor.w;

                #ifdef _MAIN_LIGHT_SHADOWS
                Light mainLight = GetMainLight(i.shadowCoord);
                #else
                Light mainLight = GetMainLight();
                #endif

                color.rgb  = lerp(color * _ShadowColor, color * _BaseColor, mainLight.shadowAttenuation);

                color.rgb = MixFog(color.rgb, fogFactor);

                return color;
            }
            ENDHLSL
        }
        // Used for rendering shadowmaps
        UsePass "Universal Render Pipeline/Lit/ShadowCaster"

        // Used for depth prepass
        // If shadows cascade are enabled we need to perform a depth prepass.
        // We also need to use a depth prepass in some cases camera require depth texture
        // (e.g, MSAA is enabled and we can't resolve with Texture2DMS
        UsePass "Universal Render Pipeline/Lit/DepthOnly"

        // Used for Baking GI. This pass is stripped from build.
        UsePass "Universal Render Pipeline/Lit/Meta"
    }
}