Creating an FPS style movement system with OpenGL and GLUT

Question

I'm trying to implement a first person movement system using GLUT and OpenGL. So far I have the strafing left to right, and forward/backward movement working correctly. However, my problem comes with the looking around. I want to be able to use the movement of the mouse to look around, like most/all FPS games. I'm using gluLookAt for all of my movement/looking around. Currently, for the looking around section, I have this (taken from a tutorial)

    gluLookAt(position.x, position.y, position.z,
        position.x + direction.x, position.y + direction.y, position.z + direction.z,
        up_vector.x, up_vector.y, up_vector.z);

Then for when there is a passive mouse movement, I check for it and do this:

horizontal_angle += 0.005* float(x - origin_x);
vertical_angle += 0.005* float(y - origin_y);

direction_vector.x = cos(vertical_angle) * sin(horizontal_angle);
direction_vector.y = sin(vertical_angle);
direction_vector.z = cos(vertical_angle) * cos(horizontal_angle);

position.x = sin(horizontal_angle - 3.14f/2.0f);
position.y = 0.0f;
position.z = cos(horizontal_angle - 3.14f/2.0f);

up_vector = crossProduct(right_vector, direction_vector);

However, this is giving me some really weird, wobbly effect, not particularly close to the one I want.

Daniel · Accepted Answer · 2014-10-06T07:09:05.907

First off, as far as I know gluLookAt is deprecated, you should consider looking at GLM its a math library that handles pretty much all the mathy stuff for you if you don't want to delve down to that level.

Secondly, you could look at using quaternionsfor your rotation of your camera, they are a lot smoother that just using normal trigonometry for your camera rotation and they also don't suffer from gimbal lock. As far as I can remember GLM does have an implementation for quaternions but you can always implement it yourself as well I've done it a long time back and I got it right, so I couldn't have been to hard. :P

If you do want to stick to the trig for now though, here is my old rotate function before I changed to quaternions:

void Camera::rotateCamera(int xDelta, int yDelta, int xMid, int yMid)
{
    const GLfloat X_SCALED = (GLfloat)xDelta / (GLfloat)xMid;
    const GLfloat Y_SCALED = (GLfloat)yDelta / (GLfloat)yMid;
    const GLfloat ANGLE_DELTA = 2 * 360.0f / 360.0f * 3.14f;
    const GLfloat LEFT_RIGHT_ROT = X_SCALED * ANGLE_DELTA;
    const GLfloat UP_DOWN_ROT = Y_SCALED * ANGLE_DELTA;


        direction = d - r;
        vec3 right = cross(direction, u);
        vec4 temp(direction.x, direction.y, direction.z, 0.0f);

        mat4 identity;
        identity = rotate(identity, UP_DOWN_ROT, right);
        identity = rotate(identity, LEFT_RIGHT_ROT, u) ;

        temp = identity * temp;

    d = r;
    d[0] += temp[0];
    d[1] += temp[1];
    d[2] += temp[2];

    view = lookAt(r,d,u);
}

xDelta is the amount that your mouse has moved from the centre of your screen, and xMid is the middle of your screen. r is the eye of your camera, d is the direction its facing and u is its up vector.

If you have any questions just ask me :)

UPDATE:

Here is the initial article that I used for my implementation of a quaternion based camera.

My best advice would just be to try and stay away from euler angles, they lose precision and can cause weird artefacts for movement and rotation.

Thanks for your reply, I think I will go with Quaternions, seems to be a better option! — Finn, Oct 02 '14 at 01:40
The gimbal lock is a consequence of the way our head rotates, i.e. when you look straight up or straight down you have a singularity. Your 'quaternion based solution' avoids the gimbal lock not by the virtue of quaternions but by clamping the pitch away from the poles so you cannot look straight up or straight down. You can clamp the Eular angles too, thus avoiding the problem. If you don't clamp then quaternion won't save you, because when `View - Position` gets parallel to `Up`, then their cross products drops to zero and you get the dreaded gimbal lock. — Yakov Galka, Jan 02 '16 at 22:47

score 2 · Answer 2 · answered Oct 01 '14 at 10:13

The way you are doing it seems right to me except the position part:

position.x = sin(horizontal_angle - 3.14f/2.0f);
position.y = 0.0f;
position.z = cos(horizontal_angle - 3.14f/2.0f);

it should be like that:

vector right_vector = crossProduct(direction_vector, vector(0, 1, 0)); // maybe crossProduct(vector(0, 1, 0), direction_vector)

float speed = 3; // you decide the value.

if ( GetKey(Key_Forward) == Key_Pressed ) {
 position.x += (direction_vector.x * speed);
 position.y += (direction_vector.y * speed);
 position.z += (direction_vector.z * speed);
} else if ( GetKey(Key_Back) == Key_Pressed ) {
 position.x -= (direction_vector.x * speed);
 position.y -= (direction_vector.y * speed);
 position.z -= (direction_vector.z * speed);
}
if ( GetKey(Key_Right) == Key_Pressed ) {
 position.x += (right_vector.x * speed);
 position.y += (right_vector.y * speed);
 position.z += (right_vector.z * speed);
} else if ( GetKey(Key_Back) == Key_Pressed ) {
 position.x -= (right_vector.x * speed);
 position.y -= (right_vector.y * speed);
 position.z -= (right_vector.z * speed);
}

GetKey() and Key_Pressed depends on the API you use hope it works for you, :).

Creating an FPS style movement system with OpenGL and GLUT

2 Answers2