OpenGl rotations and translations

Question

I am building a camera class to look arround a scene. At the moment I have 3 cubes just spread arround to have a good impression of what is going on. I have set my scroll button on a mouse to give me translation along z-axis and when I move my mouse left or right I detect this movement and rotate arround y-axis. This is just to see what happens and play arround a bit. So I succeeded in making the camera rotate by rotating the cubes arround the origin but after I rotate by some angle, lets say 90 degrees, and try to translate along z axis to my surprise I find out that my cubes are now going from left to right and not towards me or away from me. So what is going on here? It seems that z axis is rotated also. I guess the same goes for x axis. So it seems that nothing actually moved in regard to the origin, but the whole coordinate system with all the objects was just rotated. Can anyone help me here, what is going on? How coordinate system works in opengl?

Answer 1

You are most likely confusing local and global rotations. Usual cheap remedy is to change(reverse) order of some of your transformation. However doing this blindly is trial&error and can be frustrating. Its better to understand the math first...

Old API OpeGL uses MVP matrix which is:

MVP = Model * View * Projection

Where Model and View are already multiplied together. What you have is most likely the same. Now the problem is that Model is direct matrix, but View is Inverse.

So if you have some transform matrix representing your camera in oder to use it to transform back you need to use its inverse...

MVP = Model * Inverse(Camera) * Projection

Then you can use the same order of transformations for both Model and Camera and also use their geometric properties like basis vectors etc ... then stuff like camera local movements or camera follow are easy. Beware some tutorials use glTranspose instead of real matrix Inverse. That is correct only if the Matrix contains only unit (or equal sized) orthogonal basis vectors without any offset so no scale,skew,offset or projections just rotation and equal scale along all axises !!!

That means when you rotate Model and View in the same way the result is opposite. So in old code there is usual to have something like this:

// view part of matrix
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glRotate3f(view_c,0,0,1); // ugly euler angles
glRotate3f(view_b,0,1,0); // ugly euler angles
glRotate3f(view_a,1,0,0); // ugly euler angles
glTranslatef(view_pos);   // set camera position
// model part of matrix
for (i=0;i<objs;i++)
    {
    glMatrixMode(GL_MODELVIEW);
    glPushMatrix();
    glTranslatef(obj_pos[i]);   // set camera position
    glRotate3f(obj_a[i],1,0,0); // ugly euler angles
    glRotate3f(obj_b[i],0,1,0); // ugly euler angles
    glRotate3f(obj_c[i],0,0,1); // ugly euler angles
    //here render obj[i]
    glMatrixMode(GL_MODELVIEW);
    glPopMatrix();
    }

note the order of transforms is opposite (I just wrote it here in editor so its not tested and can be opposite to native GL notation ... I do not use Euler angles) ... The order must match your convention... To know more about these (including examples) not using useless Euler angles see:

• Understanding 4x4 homogenous transform matrices

Here is 4D version of what your 3D camera class should look like (just shrink the matrices to 4x4 and have just 3 rotations instead of 6):

• reper4D

pay attention to difference between local lrot_?? and global grot_?? functions. Also note rotations are defined by plane not axis vector as axis vector is just human abstraction that does not really work except 2D and 3D ... planes work from 2D to ND

PS. its a good idea to have the distortions (scale,skew) separated from model and keep transform matrices representing coordinate systems orthonormal. It will ease up a lot of things latter on once you got to do advanced math on them. Resulting in:

MVP = Model * Model_distortion * Inverse(Camera) * Projection