(Bilboard Shader) Max Screen Size

I'm stuck ! I want to limit the size of a particle in my Geometry Shader, just like in the Shuriken particle system. Bu i just don't have a clue how to calculate the screen size and in turn limit it. Here is my Geometry and vertex functions:

 // Vertex Shader ------------------------------------------------
                 GS_INPUT VS_Main(appdata v)
                 {
                     GS_INPUT output = (GS_INPUT)0;
                     output.color = v.color;
                     output.pos =  mul(_Object2World, v.pos);
                     output.info =  float4(v.info,0,0);
                     return output;
                 }
 
 
                 // Geometry Shader -----------------------------------------------------
                 [maxvertexcount(4)]
                 void GS_Main(point GS_INPUT p[1], inout TriangleStream<FS_INPUT> triStream)
                 {
                     //inverse view matrix
                     float4x4 i_v = inverse(UNITY_MATRIX_V);
                     float4 pos = p[0].pos;
                     float distance = length(_WorldSpaceCameraPos - pos);
                     float3 look = normalize(_WorldSpaceCameraPos - pos);
                     float3 up = float3(0,1,0);
                     
                     //the rotation matrix
                     float4x4 rotateM = rotate(float3(0,0,sin(p[0].pos.x) * _Time.y),float4(0,0,0,0));
                     up = mul(rotateM,up);
                     //rotate the up vector to match the camera up
                     up =  mul(i_v,up);
                     float3 right = cross(up, look);
                     //individual size of particle
                     float size = p[0].info.x;
                     
                     //quad vertices centered on 0,0 
                     float4 v[4];
                     v[0] = float4(right * 0.5f  - up * 0.5f,0);
                     v[1] = float4(right * 0.5f + up * 0.5f, 0);
                     v[2] = float4(- right * 0.5f - up * 0.5f, 0);
                     v[3] = float4(- right * 0.5f + up * 0.5f, 0);
                     
                     float2 u[4];
                     u[0] = float2(1,0);
                     u[1] = float2(1,1);
                     u[2] = float2(0,0);
                     u[3] = float2(0,1);
 
                     FS_INPUT pIn;
                     //use the look direction as the normal
                     pIn.normal = look;
                     pIn.color = p[0].color;
                     //store the distance of each particle
                     pIn.info = float4(distance,0,0,0);
                     
                     for(int i = 0;i < 4;i++)
                     {
                         pIn.pos = mul(UNITY_MATRIX_VP,pos + v[i] * size);
                         pIn.tex0 = u[i];
                         triStream.Append(pIn);
                     }
                 }

I don't know how to limit the screen size with this setup. I would love some suggestions.