In both 2D and 3D, rotations are simply the application of a matrix to a vector. For successive rotations along several axes, the final rotation matrix is equal to the multiplication of each matrix. Please note : multiplication is used here to mean matrix multiplication. The result of multiplying one matrix by another matrix is always a matrix.

Remember also that matrix multiplication is not commutative. This means that the order in which the rotations are applied is important. This is easily illustrated by taking (for example, but it's not the only one) the dimensions of each matrix. If matrix MA has size l1 x c1 and matrix MB l2 x c2, then the multiplication of MA by MB exists only if c1 = l2 and, conversely, MB by MA exists only if l1 = c2.

OK let's stop talking mathematics. The problem to be solved here is how to apply a rotation around any axis that has already undergone one or more rotations.

The "easiest" solution is to use quaternions for this. Quaternion number is just an extension of the complex numbers. The imaginary part of a classic complex number is denoted i and multiplying a real number by i applies a 90° rotation. That's "1D". Naturally, for 3D, it's reasonable to add other dimensions to these numbers, which go from complex to hypercomplex. We then have a number of the form a + ib + jc + kd. In all honesty, it sounds powerful but requires a level of mathematics that I don't have. Damm ! I'm back on the maths.

As usual, POVRay has some powerful features that will help us in this task. This is the internal function called : vaxis_rotate(V1, V2, A). As the documentation indicates, this macro rotate vector "V1" about axis "V2" by angle "A", and we also have her little sister : Axis_Rotate_Trans(Axis, Angle).



The animation below (mp4 / 556 Ko/ 8 fps) shows the successive rotations of a sphere around several axes.



The principle is as follows.


• Phase 1 : rotation around the  x ⃗ axis.

#declare RotationAngle1 = 20;
#declare AngleX = clock*RotationAngle1;
object { TheSphere rotate AngleX*x }

After the rotation around  x ⃗ , we have two "new"  y ⃗ and  z ⃗ axes which can easily be calculated using the vaxis_rotate( ) method :

#declare NewYAxis = vnormalize( vaxis_rotate(y,x,RotationAngle1));
#declare NewZAxis = vnormalize( vaxis_rotate(z,x,RotationAngle1));

• Phase 2 : rotation around the new  y ⃗ axis.

#declare RotationAngle2 = 30;
#declare AngleY = clock*RotationAngle2;
object { TheSphere Axis_Rotate_Trans(NewYAxis, AngleY) }

Applied to TheSphere object already oriented with respect to  x ⃗ in accordance with phase 1 in this example.


• Phase 3 : rotation around the new  z ⃗ axis (which has been rotated twice).

#declare RotationAngle3 = 45; 
#declare TheSphere = object { TheSphere rotate RotationAngle1*x }
#declare TheSphere = object { TheSphere Axis_Rotate_Trans(NewYAxis, RotationAngle2) }

#declare AngleZ = clock*RotationAngle3;
object { TheSphere Axis_Rotate_Trans(NewZAxis, AngleZ) }

The final result for the three axes :

#declare NewXAxis = vnormalize( vaxis_rotate(NewXAxis, NewZAxis,RotationAngle3));
#declare NewZAxis = vnormalize( vaxis_rotate(NewZAxis, NewZAxis,RotationAngle3));
#declare NewYAxis = vnormalize( vaxis_rotate(NewYAxis, NewZAxis,RotationAngle3));

An other situation : suppose we have an axis represented below by the magenta vector named  q ⃗ . The aim is to reorientate an object along this axis and then rotate it. A translation along this axis has also been added in this demo (mp4 / 556 Ko / 30 fps).



The object to be moved is shown in green here. First operation : reorients the object on the chosen axis. This operation is easily performed using the Reorient_Trans(Axis1, Axis2) macro, described in the POV documentation and part of "transforms.inc". This macro aligns Axis1 to Axis2 by rotating the object around a vector perpendicular to both Axis1 and Axis2. We have Axis1 = y ⃗ and Axis2 = q ⃗ . So we have a code like this  :

#declare Object = object { Object Reorient_Trans(y, q) }

Once this is done, all that remains is to use the Axis_Rotate_Trans(Axis, Angle) macro to rotate the object on the chosen axis. Done with this code in which translation along the axis is added :

#declare Angle = clock*360;
#declare Trans = clock*q;
object {
  Object
  Axis_Rotate_Trans(q, Angle)
  translate q*Trans
  }

That's all. I hope these explanations and examples are clear enough to help you understand or discover how it all works.



A few notes :

• Everything said here works if, and only if, the axes pass through the origin.
• You can (and should) also have a look at the excellent t-o-k site, which has created a library containing a whole of macros for transforming vectors.
• The "trans" in the name of the macros has nothing to do with "translation" but rather with "transformation".