public function Transform3DPoints(p, r) {
		var sinx = Math.sin(r.x);
		var cosx = Math.cos(r.x);
		var siny = Math.sin(r.y);
		var cosy = Math.cos(r.y);
		var sinz = Math.sin(r.z);
		var cosz = Math.cos(r.z);

		var x = p.x;
		var y = p.y;
		var z = p.z;
		var xy = cosx*y-sinx*z; // cos(r.x) * y - sin(r.x)
		var xz = sinx*y+cosx*z; // sin(r.x) * y + cos(r.x) * z
		
		var yx = siny*xz+cosy*x; // sin(r.y) * (sin(r.x) * y + cos(r.x) * z) * x
		var yz = cosy*xz-siny*x; // cos(r.y) * (sin(r.x) * y + cos(r.x) * z) - sin(r.y) * x

		var zx = cosz*yx-sinz*xy; // cos(r.z) * sin(r.y) * (sin(r.x) * y + cos(r.x) * z) * x) - sin(r.z) * cos(r.x) * y - sin(r.x)
		var zy = sinz*yx+cosz*xy; // sin(r.z) * (sin(r.y) * (sin(r.x) * y + cos(r.x) * z) * x) + cos(r.z) * (cos(r.x) * y - sin(r.x))
		
		scaleRatio = focalLength/(focalLength+yz);
		x = zx*scaleRatio;
		y = zy*scaleRatio;
		z = yz;
		
		var transformed = make3DPoint(z,y,z);
		return transformed;
	}

Quote:Original post by Trienco
Have a look at them when you get around to it and have time, but if anyone claims they promise eternal life and happiness or can do things that matrices can't, then I would assume the person just doesn't know what matrices can do. Figure out where they are cheaper and where they are more expensive (and where the benefit justifies the hassle). They are a bit like pluecker coordinates. Looking really nice and cool for certain things, but also introducing extra work that may or may not negate whatver benefit they bring.

Quote:Original post by Trienco
Have a look at them when you get around to it and have time, but if anyone claims they promise eternal life and happiness or can do things that matrices can't, then I would assume the person just doesn't know what matrices can do.

Quote:Original post by AndyTX

Quote:Original post by Trienco
Have a look at them when you get around to it and have time, but if anyone claims they promise eternal life and happiness or can do things that matrices can't, then I would assume the person just doesn't know what matrices can do.

For sure: both matrices and quaternions are a complete description of orientation in 3D space. I wouldn't so quickly write off either though.

The advantages I see of quaternions:

1) Interpolation! Slerp is by far the biggest reason for using quaternions for animation, and I have seen no good derivation of it that uses matrices. Since it is so natural and cheap to do with quaternions, I also doubt that the matrix equivalent would be simpler OR faster.

2) Composing rotations is cheaper - with matrices it requires 9 (!) dot products, and quaternions only require a handlefull of mads.

3) Renormalizing a quaternion is much cheaper than reorthogonalizing a 3x3 matrix.

4) Their most natural geometric analog is the axis/angle representation, which is intuitive. Going between the two is very cheap for quaternions, and much more expensive for matrices.

5) Less storage/redundancy... not very significant in modern engines though.

Anyways I discount storage as a very valid comparison metric in most cases, and for the most part even performance is irrelivent (I've not yet come across a game engine that is CPU geometry transform limitted... maybe for software skinning, but that's probably better done in hardware nowadays).

That said I guess what it comes down to with quaternions is that there aren't many DISADVANTAGES of using them instead of rotation matrices. If you ever require the rotation matrix, they are readily converted cheaply. Composing quaternions is easy and cheap, renormalizing is very cheap, and most of all, with a nicely coded quaternion class, they are a drop-in replacement for 3x3 rotation matrices.

In any case I don't think it matters much which one you use, but I can see no compelling argument against using quaternions (even if you don't understand the math (which isn't really too difficult), there are plenty of FAQs that go as far as giving you the code to use...), and as far as I know, quaternions still have the interpolation card to play, which is huge once your engine stops just showing static scenes :)