ps_1_3

tex t0			//diffuse color texture
tex t1			//nornmal map in tangent space
texdp3tex t2, t1_bx2	//H as coord, specular function pow(N.H,16) as 1D tex
tex t3			//L normalized by cube map
			
dp3 r0, t3_bx2, t1_bx2	//diffuse term
			
mul r0.rgb, t0, v0	//diffuse*(vertex diffuse)
+mul r0.a, r0, t3_bx2.z	//(self shadow)*(diffuse term)
			
mul r0.rgb, r0, r0.a	//(diffuse term)*(diffuse color)
+mul t2.a, t2, t3_bx2.z	//(self shadow)*(specular term)
			
mul r1, t2.a, v1	//(specular term) * (vertex specular)
			
add_sat r0, r0, r1	//diffuse + specular

ps_1_3

//light in c0 in object space computed by the cpu

tex t0			//diffuse color texture
tex t1			//nornmal map in object space
texdp3tex t2, t1_bx2	//H as coord in obj space (const), spec func as 1D tex
tex t3 			//vertex N (obj space) renormalized

dp3 r0, c0, t1_bx2	//diffuse term

mul r0.rgb, t0, v0	//diffuse*(vertex diffuse)
+mul r0.a, r0, t3_bx2.z	//(self shadow)*(diffuse term)

mul r0.rgb, r0, r0.a	//(diffuse term)*(diffuse color)
+mul t2.a, t2, t3_bx2.z	//(self shadow)*(specular term)

mul r1, t2.a, v1	//(specular term) * (vertex specular)

add_sat r0, r0, r1	//diffuse + specular

Quote:

Original post by Kasper Fauerby I just thought of a short follow-up to my previous post in this thread... Actually more and more people are starting to use ZBrush to generate extremely high-detailed normal maps for stuff like characters. And even though ZBrush can also output its dot3-maps in tangent-space you could say that it actually works with object-space bumpmapping, since it *will* generate a region in the dot3 map for each polygon (as far as I know). So even though object-space bumpmapping can be quite demanding on texture resources it still has its uses... - Kasper Fauerby

Quote:

Original post by SimmerD Tangent space has some other benefits. One is filtering, you can perform screen-space effects on a tangent space normal map. Object space doesn't work for this. For similar reasons, mip-mapping object space normal maps doesn't work well. What normal do you use for the 1x1 mip-map for an object space texture? For tangent space, you choose [0,0,1] Also, you can blend in decals more easily on top of a tangent space normal map.

tex t0                      //N in tangent space

texm3x3pad t1, t0_bx2       // transform N to light space and
texm3x3pad t2, t0_bx2       // reflect light space eye vector (t1.w,t2.w,t3.w)
texm3x3vspec t3, t0_bx2     // by N and look up R in cube texture

Quote:

Thank you for that. I didn't know texm3x3vspec was that much slower.

Quote:

The self shadowing looks different from what I had too but I remeber to have seen that saturate(light.z*8) thing in some nVidia paper and it makes sense.

Quote:

It worries me a bit that v0 is not renormalized per pixel but I think the light.z*8 will take care of that.

Quote:

A last question is about transparency. When the alpha channel of the base texture contains the transparency of an object it cannot be accessed in the specular pass. Should the former pass write it to framebuffer alpha? But this is used to store attenuation when a point light or something is used (at least I did it this way). Or is it just unnaccessary for specular hightlights to be transparent? Please shed some light onto this ;-)

Quote:

Edit: I did a quality comparison of my shader to yours using a sphere with 10*10 segments. The image quality of my shader seems slightly better to me. The highlight is always perfectly stable while in your version they "wobble" a bit (just a little bit, really). When using the same lookup cube texture my shader's highlights seem to be smaller though. I guess the reason for all this is that N.H is just an approximation of R.L. Unfortunately I don't have a reference image. On the other hand I just want to produce something that looks good while running at good frame rates so your shader will probably be the better choice.

Quote:

Original post by SimmerD Its great to see others pushing the shaders on ps.1.1 hardware. I had quite a few challenges getting good looking specular effects myself. What I did was to completely cheat! I wanted all lighting ( diffuse & specular normal mapped ) in a single pass, b/c I'm doing shadows and may have many lights in a scene. So, I couldn't do real specular powers, instead I used the old trick of rescaling the eye vector by a bumpiness factor in the vertex shader, then pass this into a cubemap. I use the eye vector instead of n.h or r.l because it's linear ( no wobbles ), and the highlight always shows up on flat floors. I use a cubemap to renormalize the eye vector, then use math to combine the diffuse + "specular" terms. By varying the bumpheight you can make the highlight grow or shrink, but it does have other effects on the bump mapping by making it more or less prominent...

Quote:

Original post by SimmerD That's exactly what I meant. The idea is that once the light vector is moved into tangent space, you then multiply it by [ 1 1 0.5 ]. The cubemap renormalizes for you. This distorts the light vector so it is more flat. This effectively makes the light look like its coming more 'from the side'. On a mainly flat surface, it also makes the highlight area smaller, as the angular attenuation falls off more sharply as the light moves from directly above the surface off to one side. Alternately, you can multiply by [ 2.0 2.0 1 ] and get the same effect - either scale x & y up or z down to make things bumpier and the highlight tighter, or the other way to make things less bumpy and the highlight broader. In the limit, if your bump height is [ 1 1 0.0001 ] then the bumps pretty much disappear completely. You can use this trick to animate the amount of bump mapping on a surface in real-time. I have separate scaling factors for the diffuse L vector and the 'specular' E vector so that you can play with them separately. This way the surface still looks bumpy from the diffuse lighting, and only the specular bumpiness is changed.

Quote:

Original post by EvilDecl81 Object spaced bump mapping is used in alot of applications, because in some cases it is easier. Tangent space bump mapping is more powerful however. Many people transform object space into tangent space when they are using a package like zbrush. Filtering problems are easier, and you save an eneroumous amount of memory. Not just becuase you can tile, but also because you can store the only the x, y and compute the z, AND because the precision of doing this gives you more precise normals pointing straight up, which is where you want higher precision. This combines to give you much more effective use of memory. Additionally, with tangent space, you can store the x,y of the normal in the r,g channels of the texture, Ks in the z, and the power in w component. Varying the power and Ks usually have more impact then changing the normal...

Quote:

Original post by SimmerD I just use (E.N)^2 for the specular effect. Works pretty well for me so far.

Quote:

There is a way to rederive z given a guess ( based on newton-raphson ). If you pass in specular in oD0, for example, you can do a renormalize in the pixel shader in two instructions on ps.1.1. It only works if the vector is normalized in the vertex shader ( which is not correct for H ), because if the value is too small, the approximation breaks down. You could pass in just E.z in oD0.a from the vertex shader, then grab x,y,0 from a normal map, add in the z from diffuse alpha, and then do the renormalization trick. From the NVIDIA GPU Programming Guide : assuming the unnormalized vector is in v0, dp3_sat r1, v0_bx2, v0_bx2 mad r1, v0_bias, 1-r1, v0_bx2 This will approximately renormalize v0 into r1.

Quote:

Original post by muhkuh Quote: Original post by EvilDecl81 Object spaced bump mapping is used in alot of applications, because in some cases it is easier. Tangent space bump mapping is more powerful however. Many people transform object space into tangent space when they are using a package like zbrush. Filtering problems are easier, and you save an eneroumous amount of memory. Not just becuase you can tile, but also because you can store the only the x, y and compute the z, AND because the precision of doing this gives you more precise normals pointing straight up, which is where you want higher precision. This combines to give you much more effective use of memory. Additionally, with tangent space, you can store the x,y of the normal in the r,g channels of the texture, Ks in the z, and the power in w component. Varying the power and Ks usually have more impact then changing the normal... Mmmm. I think this applies only to ps 2.0 hardware doesn't it? I don't think my GF4 can do z=sqrt(1- x² - y²) per pixel except using a texture lookup but this would burn another texture unit. What do you mean by power and Ks? Is power the specular power value so it can change per pixel?

Quote:

Original post by EvilDecl81 Yes it is ps_2_0, though you could do something in ps_1_4 if you were clever.

Quote:

Ks is part of the Blinn-Phong Lighting Equation (assuming a white light of intensity 1), Kd * dot( N, L) + Ks * pow( dot (H, N), power )

Quote:

My point is only that Ks and power are _more_ important then the N is for specular highlights of any reasonably high power (say, 10+). That is, I wouldn't even bother doing any kind of specular bump mapping if you aren't varying Ks and power, and if given a choice, keep N the same (0,0,1) (for the specular part) and vary Ks and power instead. For most bumpmaps, Ks and power have _far_ more impact on the reflection equation then the Normal will.

Quote:

Original post by SimmerD I just use (E.N)^2 for the specular effect. Works pretty well for me so far.

Quote:

Original post by muhkuh I'm not a native speaker but my translation of this means something slightly rude. I will optimistically assume that either I didn't understand this correctly or you wrote this unintentionally and didn't want to imply something about my mental abilities. But as long as you share your knowledge with me I'll be quite permissive. ;-)