Camera GimbalLock


Which could be the best way to avoid Gimbal Lock.
There is an exemple of how my camera work.

class CCamera
  CVector m_Position;  // Camera position
  CVector m_Right;     // Right vector
  CVector m_Up;        // Up vector
  CVector m_Direction; // Direction

  void Move_X( float Speed )
    /* QUESTION : Here, should I save a the 
                  speed value and use it only when 
                  I build up the cam matrix in the 
                  Update() function ?

    // X Axis of the camera
    CVector vAxeX;
    vAxeX.Set( m_Right.X(), m_Up.X(), m_Direction.X() ) *= (-Speed);

    // Move along the (local) X axis of the camera 

    m_Position += vAxeX;

  void RotationX( float Degres )
    /* QUESTION : Here, should I save a the 
                  Pitch angle, and use it in the 
                  Update() function when
                  I build up the cam matrix ?

    m_Right.RotationX( -Degres ).Normalise();
    m_Up.RotationX( -Degres ).Normalise();
    m_Direction.RotationX( -Degres ).Normalise();

  CMatrix GetMatRotation(void)

  CMatrix GetMatTranslation(void)

void Update(void)
// Activate the Modelview matrix
glMatrixMode( GL_MODELVIEW );

// Build the new matrix
CMatrix MatCamera;
MatCamera = GetMatTranslation() * GetMatRotation();

// Loading the new matrix
glLoadMatrixf( MatCamera.Inverse() );


Should I use Quaternion ?
Cause, Quaternion give me some difficulty to keep my Right, Up, Direction vector working…
Pretend I’m using Quaternion, I should use EULER angle to rotation (Pitch, Yaw, Roll).
Create a Quaternion from those value… And build up the new rotation matrix.

Now, pretend I want to implement a LookAt() function,
I will my Right, Up and Direction Vector…
How could I keep those one working ?

When using Quaternion, we always need to convert Matrix
to Quat, Quat to Matrix… Too many calculs

Please Help me.

[This message has been edited by Erakis (edited 10-08-2002).]

If you want to avoid gimbal lock, you must apply changes to the orientation as a matrix or a quaternion, not euler angles.

You can store the orientation as euler angles, but then to change the orientation you must: convert to a matrix or quat, apply the changes, then convert back. It’s easier to just store the orientation as a quat or a matrix.

In your case, you are using a matrix - up, dir, and right vectors effectively form a rotation matrix. I don’t think you will have a problem with gimbal lock with your current setup.

[This message has been edited by Jambolo (edited 10-10-2002).]