In article <4a1h4l\$ov4@newsy.ifm.liu.se>, d94marka@isy.liu.se says... > >paradise@ajax.umcs.lublin.pl (Marcin Jaskowiak) wrote: >>for bump mapping, modify interpolated normal by value of texture >>(you must do shading + t.mapping for bump maps). >> >>cya > >Wrongo. Modify interpolated normal by the LOCAL DERIVATE of >the texture. It works like this. A surface normal is not just a vector, it's a "tensor product" between two co-planar vectors: N = du/dt x dv/dt (x=cross product) where du/dt = unit vector lying along the surface in the "u" texture direction. dv/dt = similar in the "v" texture direction. Picture a grid texture map mapped onti, say, a sphere. The horizontal lines (u axis) are mapped to concentric circles around the sphere. The vertical lines (v axis) map to lines that meet at the top and bottom of the sphere. (Side note: ever tried rotating a grid-type-pattern texture map before applying it to a sphere? Cool!) You can construct unit vectors for du/dt and dv/dt quite easily, (especially on a ploygon) and the cross product between these is the surface normal. Now, if you mess around with these du/dt and dv/dt vectors before calculating the surface normal, you now have a controllable method of displacing the surface normal w.r.t. a texture map. Take a height map h[x][y] which is a bitmap with a value for every pixel that is proportional to the height it represents. You need to calculate the *change* in height in the u and v directions (I'm assuming you know the texture (u,v) coordinate for the point you're shading)... int map_width = 256; int map_height = 256; int s = (map_width-2) * u; // u in range 0..1; int t = (map_height-2) * v; // v in range 0..1; float du = h[u+1][v] - h[u][v]; float dv = h[u][v+1] - h[u][v]; Plenty of scope for anti-aliasing the sampling here. The "-2" is because you need -1 for counting from 0, minus another 1 because you will be accessing h[u+1][u]. These values for du,dv can be used to perterb the surface normal: float k = 0.01; // how bumpy the surface is vector dudt = dudt + N * (k * du); // vector + vector * scalar vector dvdt = dvdt + N * (k * dv); // vector + vector * scalar What we've done here is to add a small amount if an upwards direction to the surface derivitives. Imagine the plane the normal is resting on being rotated and perterbed. Now recalculate the normal: N = cross(dudt,dvdt); // cross product N = renormalise(N); // renormalise to unit vector There you have a bump mapped normal. -- ----------------------------------------------------------------------- Robin Green, Technical Specialist rgreen@ea.com Electronic Arts Ltd UK. Tel:01753 772353 EA has no opinions -----------------------------------------------------------------------