Shaders: Make Mesh partly visible with Shadows

Hi

I am using a Shader to cut all Meshes above a specific Y level. This is working but the Shadows that are generated are wrong. How i can correct this? The left picture shows the problem and in the right picture there is nothing cuttet. (U can Ignore the trees)

Here is my Shader:

 Shader "Test/Rim Shading Multiple Lights Texture Shadows" {
 Properties{
         _Color ("Color",Color) = (1.0,1.0,1.0,1.0)
         _MainTex("Diffuse Texture",2D) = "white"{}
         _SpecColor("SpecColor",Color) = (1.0,1.0,1.0,1.0)
         _Shininess("Shininess",Float) = 10
         _RimColor ("Rim Color", Color) = (1.0,1.0,1.0,1.0)
         _RimPower("Rim Power",Range (0.1,10.0)) = 3.0
         _LastVisibleY("LastVisibleY", Float) = 50.0
     }
     
     SubShader {
         Pass{
 
         Tags{"LightMode" = "ForwardBase"}
         
             CGPROGRAM
             #pragma vertex vert
             #pragma fragment frag
             
             #include "UnityCG.cginc"
             #pragma multi_compile_fwdbase
             #include "AutoLight.cginc"
             
             //user defined Variable
             uniform sampler2D _MainTex;
             uniform float4 _MainTex_ST;
             uniform float4 _Color;
             uniform float4 _SpecColor;
             uniform float4 _RimColor;
             uniform float _Shininess;
             uniform float _RimPower;
             
             uniform float _LastVisibleY;
             //unity defined Variables
             uniform float4 _LightColor0;
             
             struct vertexInput{
                 float4 vertex : POSITION;
                 float3 normal : NORMAL;
                 float4 texcoord : TEXCOORD0;
                 
             };
             
             struct vertexOutput{
                 float4 pos : SV_POSITION;
                 float4 tex : TEXCOORD0;
                 float4 posWorld : TEXCOORD1;
                 float3 normalDir : TEXCOORD2;
                 LIGHTING_COORDS(3,4)
             };
             
         
             
             
             vertexOutput vert(vertexInput v)
             {
                 vertexOutput o;
                 o.pos = mul(UNITY_MATRIX_MVP, v.vertex);
                 o.posWorld = mul(_Object2World, v.vertex);
                 o.normalDir = normalize(mul(float4(v.normal,0.0),_World2Object).xyz);
                 o.tex = v.texcoord;
                 TRANSFER_VERTEX_TO_FRAGMENT(o);
                 return o;
             }
             
             float4 frag(vertexOutput i) : COLOR
             {
             
                 if(i.posWorld.y > _LastVisibleY)
                     discard;
                 float3 normalDirection = i.normalDir;
                 float3 viewDirection = normalize(_WorldSpaceCameraPos.xyz - i.posWorld.xyz);
                 float3 lightDirection;
                 float atten;
                 
                 if(_WorldSpaceLightPos0.w == 0.0)
                 {
                     atten = 1.0;
                     lightDirection = normalize(_WorldSpaceLightPos0.xyz);
                 }
                 else
                 {
                     float3 fragmentToLightSource = _WorldSpaceLightPos0.xyz - i.posWorld.xyz;
                     float distance = length(fragmentToLightSource);
                     atten = 1/distance;
                     lightDirection = normalize(fragmentToLightSource);
                 }
                 
                 atten = atten * LIGHT_ATTENUATION(i);
                 //lighting
                 float3 diffuseReflection = atten * _LightColor0.xyz * saturate(dot(normalDirection, lightDirection));
                 float3 specularReflection =atten * _LightColor0.xyz * _SpecColor.rgb * saturate(dot(normalDirection, lightDirection)) *pow( saturate(dot(reflect(-lightDirection,normalDirection),viewDirection)),_Shininess);
                 
                 //Rim Lighting
                 float rim = 1 - saturate(dot(normalize(viewDirection),normalDirection));
                 float3 rimLighting  = atten * _LightColor0.xyz * _RimColor * saturate(dot(normalDirection, lightDirection)) * pow(rim,_RimPower);
                 float3 lightFinal = rimLighting + diffuseReflection + specularReflection + UNITY_LIGHTMODEL_AMBIENT.xyz;;
                 
                 //float atten2 = LIGHT_ATTENUATION(i)* atten;
                 
                 //Texture
                 float4 tex = tex2D(_MainTex,i.tex.xy * _MainTex_ST.xy + _MainTex_ST.zw);
                 
                 
                 return float4(tex.xyz * lightFinal * _Color,1.0);
                 
                 
             }
             
             
             ENDCG
         
         }
     
         
     }
     FallBack "VertexLit"
 }