How to make a specular shader fully transparent

I have a shader that simulates a glass effect that have all the Highlights areas opaque and the rest invisible.

Now I want a shader that make everything invisible equaly, a similar effect as to get a printscreen of a full opaque object and changing the alpha on photoshop, but in real time.

Is this possible?

The code i'm using now is this, it generate a simple specular effect, i don't know how to change the alpha now.

 Shader "Custom/MyShader" {
    Properties {
       _Color ("Diffuse Material Color", Color) = (1,1,1,1) 
       _SpecColor ("Specular Material Color", Color) = (1,1,1,1) 
       _Shininess ("Shininess", Float) = 10
    }
    SubShader {
       Pass {    
          Tags {"LightMode" = "ForwardAdd"} 
             // pass for additional light sources
          //ZWrite Off
          //Blend SrcAlpha OneMinusSrcAlpha
          Blend One One
  
          CGPROGRAM
  
          #pragma vertex vert  
          #pragma fragment frag
          #include "UnityCG.cginc"
          uniform float4 _LightColor0; 
          uniform float4 _Color; 
          uniform float4 _SpecColor; 
          uniform float _Shininess;
  
          struct vertexInput {
             float4 vertex : POSITION;
             float3 normal : NORMAL;
          };
          struct vertexOutput {
             float4 pos : SV_POSITION;
             float4 posWorld : TEXCOORD0;
             float3 normalDir : TEXCOORD1;
          };
  
          vertexOutput vert(vertexInput input) 
          {
             vertexOutput output;
  
             float4x4 modelMatrix = _Object2World;
             float4x4 modelMatrixInverse = _World2Object;
             output.posWorld = mul(modelMatrix, input.vertex);
             output.normalDir = normalize(mul(float4(input.normal, 0.0), modelMatrixInverse).xyz);
             output.pos = mul(UNITY_MATRIX_MVP, input.vertex);
             return output;
          }
  
          float4 frag(vertexOutput input) : COLOR
          {
             float3 normalDirection = normalize(input.normalDir);
  
             float3 viewDirection = normalize(
                _WorldSpaceCameraPos - input.posWorld.xyz);
             float3 lightDirection;
             float attenuation;
  
             if (0.0 == _WorldSpaceLightPos0.w) // directional light?
             {
                attenuation = 1.0; // no attenuation
                lightDirection = normalize(_WorldSpaceLightPos0.xyz);
             } 
             else // point or spot light
             {
                float3 vertexToLightSource = 
                   _WorldSpaceLightPos0.xyz - input.posWorld.xyz;
                float distance = length(vertexToLightSource);
                attenuation = 1.0 / distance; // linear attenuation 
                lightDirection = normalize(vertexToLightSource);
             }
  
             float3 diffuseReflection = 
                attenuation * _LightColor0.rgb * _Color.rgb
                * max(0.0, dot(normalDirection, lightDirection));
  
             float3 specularReflection;
             if (dot(normalDirection, lightDirection) < 0.0)
             {
                specularReflection = float3(0.0, 0.0, 0.0);
             }
             else
             {
                specularReflection = attenuation * _LightColor0.rgb 
                   * _SpecColor.rgb * pow(max(0.0, dot(
                   reflect(-lightDirection, normalDirection), 
                   viewDirection)), _Shininess);
             }
  
             
             return float4((diffuseReflection) + (specularReflection), 1.0);
          }
  
          ENDCG
       }
        
    }
    Fallback "Specular"
 }