Smoothing Normals in Atmospheric Shader

I have a scene in which I am attempting to render a somewhat photorealistic view of Earth from orbit. The shaders I am using are coming from Scrawk Blog. The shader for the ground appears to be functioning as expected however the one for volumetric rendering of the atmosphere I am running into some difficulties. It would appear to me that my normals are incorrect but I truly have no experience with this. It looks, at its worst, like this...

Any ideas as to how to fix this or at least mask the error? I have tried a higher poly mesh and it does look better but still has limitations I have tried blurring but its still obvious. Or perhaps I should switch to a seperate shader all together?

 Shader "Atmosphere/SkyFromSpace" 
 {
     SubShader 
     {
         Tags {"Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent"}
         //Tags { "RenderType"="Opaque" }
         Pass 
         {
             
             Blend SrcAlpha OneMinusSrcAlpha 
             ZWrite Off
             Cull Front
             //Blend One One
         
             CGPROGRAM
             #include "UnityCG.cginc"
             #pragma target 3.0
             #pragma vertex vert
             #pragma fragment frag
             
             uniform float3 v3Translate;        // The objects world pos
             uniform float3 v3LightPos;        // The direction vector to the light source
             uniform float3 v3InvWavelength; // 1 / pow(wavelength, 4) for the red, green, and blue channels
             uniform float fOuterRadius;        // The outer (atmosphere) radius
             uniform float fOuterRadius2;    // fOuterRadius^2
             uniform float fInnerRadius;        // The inner (planetary) radius
             uniform float fInnerRadius2;    // fInnerRadius^2
             uniform float fKrESun;            // Kr * ESun
             uniform float fKmESun;            // Km * ESun
             uniform float fKr4PI;            // Kr * 4 * PI
             uniform float fKm4PI;            // Km * 4 * PI
             uniform float fScale;            // 1 / (fOuterRadius - fInnerRadius)
             uniform float fScaleDepth;        // The scale depth (i.e. the altitude at which the atmosphere's average density is found)
             uniform float fScaleOverScaleDepth;    // fScale / fScaleDepth
             uniform float fHdrExposure;        // HDR exposure
             uniform float g;                // The Mie phase asymmetry factor
             uniform float g2;                // The Mie phase asymmetry factor squared
         
             struct v2f 
             {
                 float4  pos : SV_POSITION;
                 float2  uv : TEXCOORD0;
                 float3 t0 : TEXCOORD1;
                 float3 c0 : COLOR0;
                 float3 c1 : COLOR1;
             };
             
             float scale(float fCos)
             {
                 float x = 1.0 - fCos;
                 return 0.25 * exp(-0.00287 + x*(0.459 + x*(3.83 + x*(-6.80 + x*5.25))));
             }
             
 
             v2f vert(appdata_base v)
             {
             
                 float3 v3CameraPos = _WorldSpaceCameraPos - v3Translate;    // The camera's current position
                 float fCameraHeight = length(v3CameraPos);                    // The camera's current height
                 float fCameraHeight2 = fCameraHeight*fCameraHeight;            // fCameraHeight^2
             
                 // Get the ray from the camera to the vertex and its length (which is the far point of the ray passing through the atmosphere)
                 float3 v3Pos = mul(_Object2World, v.vertex).xyz - v3Translate;
                 float3 v3Ray = v3Pos - v3CameraPos;
                 float fFar = length(v3Ray);
                 v3Ray /= fFar;
                 
                 // Calculate the closest intersection of the ray with the outer atmosphere (which is the near point of the ray passing through the atmosphere)
                 float B = 2.0 * dot(v3CameraPos, v3Ray);
                 float C = fCameraHeight2 - fOuterRadius2;
                 float fDet = max(0.0, B*B - 4.0 * C);
                 float fNear = 0.5 * (-B - sqrt(fDet));
                 
                 // Calculate the ray's start and end positions in the atmosphere, then calculate its scattering offset
                 float3 v3Start = v3CameraPos + v3Ray * fNear;
                 fFar -= fNear;
                 float fStartAngle = dot(v3Ray, v3Start) / fOuterRadius;
                 float fStartDepth = exp(-1.0/fScaleDepth);
                 float fStartOffset = fStartDepth*scale(fStartAngle);
                 
                 const float fSamples = 2.0;
             
                 // Initialize the scattering loop variables
                 float fSampleLength = fFar / fSamples;
                 float fScaledLength = fSampleLength * fScale;
                 float3 v3SampleRay = v3Ray * fSampleLength;
                 float3 v3SamplePoint = v3Start + v3SampleRay * 0.5;
             
                 // Now loop through the sample rays
                 float3 v3FrontColor = float3(0.0, 0.0, 0.0);
                 for(int i=0; i<int(fSamples); i++)
                 {
                     float fHeight = length(v3SamplePoint);
                     float fDepth = exp(fScaleOverScaleDepth * (fInnerRadius - fHeight));
                     float fLightAngle = dot(v3LightPos, v3SamplePoint) / fHeight;
                     float fCameraAngle = dot(v3Ray, v3SamplePoint) / fHeight;
                     float fScatter = (fStartOffset + fDepth*(scale(fLightAngle) - scale(fCameraAngle)));
                     float3 v3Attenuate = exp(-fScatter * (v3InvWavelength * fKr4PI + fKm4PI));
                     v3FrontColor += v3Attenuate * (fDepth * fScaledLength);
                     v3SamplePoint += v3SampleRay;
                 }
             
                 v2f OUT;
                 OUT.pos = mul(UNITY_MATRIX_MVP, v.vertex);
                 OUT.uv = v.texcoord.xy;
                 
                 // Finally, scale the Mie and Rayleigh colors and set up the varying variables for the pixel shader
                 OUT.c0 = v3FrontColor * (v3InvWavelength * fKrESun);
                 OUT.c1 = v3FrontColor * fKmESun;
                 OUT.t0 = v3CameraPos - v3Pos;
                             
                 return OUT;
             }
             
             // Calculates the Mie phase function
             float getMiePhase(float fCos, float fCos2, float g, float g2)
             {
                 return 1.5 * ((1.0 - g2) / (2.0 + g2)) * (1.0 + fCos2) / pow(1.0 + g2 - 2.0*g*fCos, 1.5);
             }
 
             // Calculates the Rayleigh phase function
             float getRayleighPhase(float fCos2)
             {
                 return 0.75 + 0.75*fCos2;
             }
             
             half4 frag(v2f IN) : COLOR
             {
                 float fCos = dot(v3LightPos, IN.t0) / length(IN.t0);
                 float fCos2 = fCos*fCos;
                 float3 col = getRayleighPhase(fCos2) * IN.c0 + getMiePhase(fCos, fCos2, g, g2) * IN.c1;
                 
                 col = 1.0 - exp(col * -fHdrExposure);
                 
                 return float4(col,col.b);
             }
             
             ENDCG
 
         }
     }
 }