I'm trying to make sprites that fade out when the camera looks away from them. Example, when the camera is facing directly at a sprite, the sprite's alpha is 100, but when the camera is facing 90* in either direction, the sprite's alpha is 0.

I'm struggling to get this working with regular programming, and I'm very very close, but my math is too weak and I just can't get it right.

As I've pulled out all my hair, I decided to see if a shader could do this and if so, maybe I could talk/bribe someone into making one for me since I can't write shaders myself.

You could simply compare the angle of the sprite to the revers angles of the camera...

If the sprite <> camera.pan * -1 alter the alpha accordingly...

That would seem the simplest method to me. Of course you could use a little more code and get more info that might help you, take a look at this thread thread
and then reference the manual for vec_to_angle and associated functions.

Hope that helps
And no...not a shader i think

That's basically what I've been trying so far. I managed to get code that works when the sprite is facing 0. It fades just right depending on the cameras angle. However when the sprite is facing a direction other than 0, the fade messes up when the camera angle hits certian points (like 1~360, or 179~-180 it seems)

Got a lot more debugging in place now so I can watch my vars closely, maybe now I can rewrite it again and get it working.

I'd really like to use a shader solution for this since I can't get it working in c-script, my math is just too weak. I found something I think may help.

I was browsing through a games files and ran across a shader that sounded interesting.

Vertex Shader:
Code:

---

#define maxTextureCoordinate      0
#define vTextureCoordinateSetMAIN vTextureCoordinateSet0

dcl_position0 vPosition
dcl_normal    vNormal

//-- transform the normal into world space
m3x3 r0.xyz, vNormal, cObjectWorldMatrix

//-- compute direction to eye
m4x3 r1.xyz, vPosition, cObjectWorldMatrix
sub r2.xyz, cCameraPosition, r1

//-- normalize direction to eye
dp3 r2.w, r2, r2
rsq r2.w, r2.w
mul r2.xyz, r2, r2.w

//-- compute texture coordinates for low angle fade
dp3 oT1.x, r0, r2
mov oT1.y, c0_0

mov oT0, vTextureCoordinateSetMAIN

---

By the comments, that sounds like just the sort of thing I'm looking for. But I know absolutely nothing when it comes to shaders, so I can't edit it myself or anything, but I figured maybe someone here could make sense of it and write up something I could use. Then again, someone who knows shader asm can see what it's doing, and could probably tell me the c-script alternative. That'd be awesome too! The comments almost tell me enough to write a c-script version, but my math is extremely weak and I just don't know how to use the vec_* commands well enough to do what it says it's doing.

Anyway, there is also a pixel shader that goes with it, but the file appears to be corrupt so I'm not sure if any important parts are missing:

Pixel Shader:
Code:

---

// sample diffuse texture map
tex t0
tex t1

//fade at low angles
mul r0, r0, t1.a // *corrupt looking text here that wont paste*

---

I don't know if thats of any use to you guys, but if it is, I would be VERY grateful if someone could put it together for me. My nebula's would look so much better if I could eliminate the sharp hard looking effect you get when looking at a sprite from the 'side'.

I'd like to bump this because I'd like something like this as well!


Any takers?

Jason

you can just do a dot product in the vertex shader and use the result to multiply with your alpha in the pixel shader:

define an hlsl function like this:
float4 Dofresnel(float3 N,float3 P)
{
float3 D = (float3)vecViewPos-P;
return (1 * dot(N,normalize(D)));
}

somewhere in your vertex shader :
float3 N = normalize(mul(inNormal,matWorld));
float3 P = mul(inPos,matWorld);
Out. fresnel = Dofresnel(N,P);

and then in your pixel shader just:
half fres=saturate(In.fresnel*3);
color.a=color.a*fres;


obviously this isn't complete code.. but it gives you the idea. I use this code for a fresnel lighting effect, but the principle is the same.
dot(worldnormal, normalize(viewpos-worldposition))