For the atmosphere, because the planet is in the way, the backfaces are really all you will ever see, especially when inside the atmosphere at lower altitudes. So yes, the artifacts you are seeing would normally be occluded by the planet geometry.
It has been a while since i have messed with this, and I am just getting back to playing with it as well, but i remember having this and a number of similar issues as well when I originally tried. Rendering the planet, or accounting for where intersection with the planet would be should take care of it. And from what I have seen, at least from my initial view, your problem is "nonexistant". I would have to delve deeper to be sure.
The other problem with using the parameters as they are is that the inner and outer radii are 10 and 10.25 respectively. An atmosphere thickness of 0.25 is extremely small, thus you get very little of the atmosphere actually visible. Try scaling your inner radius value, and thus your mesh as well, and see if that helps you evaluate whether you are getting correct result.
For the atmosphere at least, it should not matter which way the normals are, as long as it is centered at the origin. Just flip your culling based on which side of the sphere you want visible. The normals are not used directly in the calculation, though implicitly the normalization of the points on the sphere create vectors that are equivalent to the normal directions.
Here is a slight modification of your shader taking into account planet intersections to give you an idea of what it would look like. Normally rendering the planet would do this instead of handling it all in the same shader. I have not tried it from within the atmosphere, but you should probably be able to figure out if any thing needs to be changed. You can also try uncommenting the two lines in the pixel shader and playing with the exposure to see if you get better looking results. The extra intersection check I added is normally not needed as the planet and atmosphere are rendered separately with front or back faces visible respectively, that keeps the first length calculation valid for the farthest intersection.
float4x4 mWorldViewProj;float4 invWavelength;float4 vEyePos;float4 vLightDir;float cameraHeight; // The camera's current heightfloat cameraHeight2; // fCameraHeight^2float outerRadius; // The outer (atmosphere) radiusfloat outerRadius2; // fOuterRadius^2float innerRadius; // The inner (planetary) radius//float innerRadius2; // fInnerRadius^2float krESun; // Kr * ESunfloat kmESun; // Km * ESunfloat kr4PI; // Kr * 4 * PIfloat km4PI; // Km * 4 * PIfloat scale; // 1 / (fOuterRadius - fInnerRadius)float scaleDepth; // The scale depth (i.e. the altitude at which the atmosphere's average density is found)float scaleOverScaleDepth; // fScale / fScaleDepthfloat g;float g2;struct vpconn{ float4 Position : POSITION; float3 t0 : TEXCOORD0; //float DepthBlur : TEXCOORD1; float3 c0 : COLOR; // The Rayleigh color float3 c1 : COLOR1; // The Mie color};struct vsconn{ float4 rt0 : COLOR0; //float4 rt1 : COLOR1;};// The scale equation calculated by Vernier's Graphical Analysisfloat expScale (float fCos){ //float x = 1.0 - fCos; float x = 1 - fCos; return scaleDepth * exp(-0.00287 + x*(0.459 + x*(3.83 + x*(-6.80 + x*5.25))));}// Calculates the Mie phase functionfloat 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 functionfloat getRayleighPhase(float fCos2){ return 0.75 + (1.0 + fCos2);}// Returns the near intersection point of a line and a spherefloat getNearIntersection(float3 v3Pos, float3 v3Ray, float fDistance2, float fRadius2){ float B = 2.0 * dot(v3Pos, v3Ray); float C = fDistance2 - fRadius2; float fDet = max(0.0, B*B - 4.0 * C); return 0.5 * (-B - sqrt(fDet));}// Returns the far intersection point of a line and a spherefloat getFarIntersection(float3 v3Pos, float3 v3Ray, float fDistance2, float fRadius2){ float B = 2.0 * dot(v3Pos, v3Ray); float C = fDistance2 - fRadius2; float fDet = max(0.0, B*B - 4.0 * C); return 0.5 * (-B + sqrt(fDet));}vpconnAtmosphereFromSpaceVS(float4 vPos : POSITION ){ float3 pos = vPos.xyz; float3 ray = pos - vEyePos.xyz; pos = normalize(pos); float far = length (ray); ray /= far; // check if this point is obscured by the planet float B = 2.0 * dot(vEyePos, ray); float C = cameraHeight2 - (innerRadius*innerRadius); float fDet = (B*B - 4.0 * C); if (fDet >= 0) { // compute the intersection if so far = 0.5 * (-B - sqrt(fDet)); } float near = getNearIntersection (vEyePos, ray, cameraHeight2, outerRadius2); float3 start = vEyePos + ray * near; far -= near; float startAngle = dot (ray, start) / outerRadius; float startDepth = exp (scaleOverScaleDepth * (innerRadius - cameraHeight)); //float startDepth = exp ((innerRadius - cameraHeight) / scaleDepth); //float startDepth = exp (-(1.0f / 0.25)); float startOffset = startDepth * expScale (startAngle); float sampleLength = far / 1.0f; float scaledLength = sampleLength * scale; float3 sampleRay = ray * sampleLength; float3 samplePoint = start + sampleRay * 0.5f; float3 frontColor = float3 (0,0,0); for (int i = 0; i < 1; i++) { float height = length (samplePoint); float depth = exp (scaleOverScaleDepth * (innerRadius - height)); float lightAngle = dot (vLightDir, samplePoint) / height; float cameraAngle = dot (-ray, samplePoint) / height; float scatter = (startOffset + depth * (expScale (lightAngle) - expScale (cameraAngle))); float3 attenuate = exp (-scatter * (invWavelength.xyz * kr4PI + km4PI)); frontColor += attenuate * (depth * scaledLength); samplePoint += sampleRay; } vpconn OUT;// OUT.DepthBlur = ComputeDepthBlur(mul (vPos, viewMatrix)); OUT.t0 = vEyePos.xyz - vPos.xyz; OUT.Position = mul(vPos, mWorldViewProj); OUT.c0.xyz = frontColor * (invWavelength.xyz * krESun); OUT.c1.xyz = frontColor * kmESun; return OUT;}vsconnAtmosphereFromSpacePS1(vpconn IN){ float3 color = IN.c0; vsconn OUT; OUT.rt0.rgb = color.rgb; OUT.rt0.a = 1.0f; return OUT;}vsconnAtmosphereFromSpacePS(vpconn IN){ vsconn OUT; float cos = saturate(dot (vLightDir, IN.t0) / length (IN.t0)); float cos2 = cos*cos; float fMiePhase = 1.5 * ((1.0 - g2) / (2.0 + g2)) * (1.0 + cos*cos) / pow(1.0 + g2 - 2.0*g*cos, 1.5); float fRayleighPhase = 0.75 * (1.0 + cos*cos); OUT.rt0.rgb = (fRayleighPhase * IN.c0 + fMiePhase * IN.c1); //float exposure = 0.85; //OUT.rt0.rgb = 1.0 - exp(-exposure * (fRayleighPhase * IN.c0 + fMiePhase * IN.c1)); OUT.rt0.a = OUT.rt0.b; //OUT.rt1 = ComputeDepthBlur (IN.DepthBlur); return OUT;}technique AtmosphereFromSpace{pass P0{AlphaBlendEnable = true;DestBlend = ONE;SrcBlend = ONE;CullMode = CW;VertexShader = compile vs_3_0 AtmosphereFromSpaceVS();PixelShader = compile ps_3_0 AtmosphereFromSpacePS();}}
Like I said, it has been a while since I have fully messed with oneil's shaders, so there may still be some values you need to play with to get everything in scale and acting correctly from both sides of the atmosphere. I don't remember needing the saturate call I added in the pixel shader, but I definitely remember getting the artifact it causes if you remove it in my original testing. I can't remember whether or not some angles flip when moving from space to in atmosphere, but i think comparing the original variations of the shaders and where they differ should shed some light on that.
Hope that helps.
I'll have to see if I can dig up my original tests in this area, though I plan on looking into it again fully sometime soon anyway.
[Edited by - Amadeus on July 18, 2008 8:36:59 AM]
----------------------------"Whatever happens, happens..." - Spike"Only the strong survive, if they choose to leave those weaker than themselves behind." - Myself
By using PIX I discovered that the problem lies in the "startAngle" computation. Values for central pixels happen to be like -0.8 -0.9, close to -1. So when they are passed to the "expScale" function, it returns astronomical values. I've checked and double checked my implementation against dozens of implementations available here and on the net and nothing seems to be very different.
This is the source to the VS:
Vertex Shader
<br/>
