Quote:
I would like to know how to rotate a face so that the normal of that face is equal to (0,0,-1).

Build a matrix with the at being the inverse of the face normal (inverse because you said z=-1).
You'll need a guess for the "up" to build the matrix, since you have a triangle already, just take any edge.
Then invert the resultant matrix, and multiply all your verts by that matrix.
Tada. Your triangle is now at the origin, facing down negative Z.

in pseudo code:

mat.at = -FaceNormal;mat.up = normalize(tri.A - tri.B);mat.left = mat.up cross mat.atmat.up = mat.at cross mat.upmat.pos = (tri.A + tri.B + tri.C) / 3inverseMat = invert(mat);newtri.A = tri.A * inverseMat;newtri.B = tri.B * inverseMat;newtri.C = tri.C * inverseMat;

any point or ray you have in "world space" you can multiply by inverseMat to get it into your new "local space". For instance a vector from a light to the face center, you could convert into local space.
any point or ray you have in "local space" you multiply by mat to get it back to "world space".

*edit: the line "mat.up = mat.at cross mat.up" isn't really needed in the exact example I posted. The reason I included it is because your "up guess" also affects the final orientation of the matrix. You may want to use the world up <0,1,0> instead of a triangle's edge. In that case, the up and normal aren't guaranteed to be at right angles to one another, thus you have to use this line to make sure the final up is at a right angle to both at and left.

Quote:
Also a potentiality silly question: Does the value of each of elements in a normalized point have any relation to Cos? Something in the back of my mind is telling me that the normal (1,0,0) is T = cos_inv(1) = 0, where T is the angle around the X axis. Is that correct?

Errrrr...... kinda.
A normal is usually representitive of a ray from the origin to a point on a sphere of radius 1 around the origin. You can decompose that ray any way you like to figure out the rotation you'd need to move your "at" axis to line up with the ray in question. The decomposition to a rotation will, by nature of the math involved relate to sin/cos in some way.

For instance, you could decompose it as latitude/longitude
Then the point is (assuming Y is up, positive Z is at>
< sin(theta) * sin(alpha), cos(alpha), cos(theta)*sin(alpha) >

You could decompose it into euler angles around each axis, but you end up with a LOT of aliasing and order-of-operation issues.

You could decompose it to a quaternion, a succinct representation of an axis of rotation and an angle around that axis.

And, you can do what I showed above, and build a matrix that represents the coordinate space where "at" is your normal. Said matrix then represents a rotated world. Using a matrix multiply, you can rotate any point in the identity "world space" into your new "local space" and back.

[Edited by - KulSeran on December 29, 2009 2:13:03 AM]

It's more common terminology in 3D graphics, due to the way "look-at" camera matrices are constructed:

http://www.songho.ca/opengl/gl_lookattoaxes.html
http://www.opengl.org/wiki/GluLookAt_code

you may find this wiki page to have a slightly more indepth explination of why the KulSeran's method works:
http://www.devmaster.net/wiki/Coordinate_systems#Transforming_Between_Coordinate_Systems

for column major matrices, its the 4th column, for row major matrices its the 4th row. This is the translation part of a typical 4x4 graphics matrix.