I've been studying for 4 days straight trying to figure out how to make a camera that behaves like one does in FPS games. I've been lead to believe I need Quaternions for this, but I also see a lot of talk about Euler angles and Yaw/Pitch/Roll.

If it is Quaternion angles, can someone give me a very basic example of how you would make a camera look up 45 degrees using a Quaternion?

I prefer to leave the mouse calculations out because they just seem to make it more difficult to understand.

Any help would be greatly appreciated as I'm getting close to giving up :(

Thanks

Well, on the lowest level you just need setters for the camera's placement as usual for any game object. However, it is the camera control where all the nasty math really happens. As a 1st (or 3rd) person camera, the placement of the camera is bound to the player's game object by parenting. This is also standard stuff, well solved by concatenating matrixes. There usually is some freedom in rotation so that the player can look up / down and left / right relative to the orientation of the game object. On the other hand the rolling is often constraint to zero. This together would give the local orientation. The local position may be fixed for 1st person camera (as opposed to 3rd person cameras). There may be additions working on the local position like camera shaking or bobbing (a controversial topic though), depending on given circumstances. Without knowing how the camera should actually behave, giving tips for its implementation (besides the standard placement) is almost meaningless. So could you (the OP) describe us what exactly you want, how your general game object placement works, and what you have so far?

Very simple using GLM (http://glm.g-truc.net/0.9.7/index.html)

Here's how to build a rotation matrix using Quaternions and vertical/horizontal angles only

// angles in radians
float mVerticalAngle;
float mHorizontalAngle;

glm::mat4 Camera::Orientation() const
{
    glm::quaternion rotation(glm::angleAxis(mVerticalAngle, glm::vec3(1.0f, 0.0f, 0.0f)));
    rotation = rotation * glm::angleAxis(mHorizontalAngle, glm::vec3(0.0f, 1.0f, 0.0f));

    return glm::toMat4(rotation);
}

Multiply this with the FPS cameras translation matrix and you have your view matrix.

glm::vec3 mTranslation;

glm::mat4 Camera::GetCameraTransform() const
{
    return Orientation() * glm::translate(glm::mat4(1.0f), -mTranslation);
}

You all are awesome! Thanks for the replies.

So could you (the OP) describe us what exactly you want, how your general game object placement works, and what you have so far?

Right now I'm just playing with the camera. I've added it to the scene at 0, 0, 0. I've gotten it to rotate using camera.rotation.x/y. From what I've seen, other people seem to implement a vector that the camera "looks at" (using the .lookAt function). Really I just want to create a camera that allows me to look around in the scene. I put a cube at 0, 0, 5 and just want to be able to move the camera around and look at the cube from different angles. For the development I'm using Threejs (threejs.org).

Very simple using GLM (http://glm.g-truc.net/0.9.7/index.html)

Here's how to build a rotation matrix using Quaternions and vertical/horizontal angles only

// angles in radians
float mVerticalAngle;
float mHorizontalAngle;

glm::mat4 Camera::Orientation() const
{
    glm::quaternion rotation(glm::angleAxis(mVerticalAngle, glm::vec3(1.0f, 0.0f, 0.0f)));
    rotation = rotation * glm::angleAxis(mHorizontalAngle, glm::vec3(0.0f, 1.0f, 0.0f));

    return glm::toMat4(rotation);
}

Multiply this with the FPS cameras translation matrix and you have your view matrix.

glm::vec3 mTranslation;

glm::mat4 Camera::GetCameraTransform() const
{
    return Orientation() * glm::translate(glm::mat4(1.0f), -mTranslation);
}

I'm at work now, but I'll check this out when I get home. So just so I'm understanding the basics correctly...

Orientation returns a Matrix (x,y,z,w), which is two Quaternions multiplied together. I'm guessing the * has been overloaded to support multiplying Quaternions? The second part is a little difficult to understand. I can't find a resource to define what the translate method takes in and returns. Would mTranslation be the vector my camera was currently located at?

Right now I'm just playing with the camera. I've added it to the scene at 0, 0, 0. I've gotten it to rotate using camera.rotation.x/y. From what I've seen, other people seem to implement a vector that the camera "looks at" (using the .lookAt function). [...]

The look-at function is useful to align the camera once or tracking an object. It is just one possibility to control the camera.

IMO you should understand it so: The camera is an object in the world similar to a game object. It has a placement (position and orientation) and additionally field of view and other view related stuff. The camera by itself does not change its placement. Then you can apply the functionality of objects like LookingAt or Tracking or Parenting or … to control the placement in part or totally. That way gives you maximum flexibility.

[…] Really I just want to create a camera that allows me to look around in the scene. I put a cube at 0, 0, 5 and just want to be able to move the camera around and look at the cube from different angles. For the development I'm using Threejs (threejs.org).

Orientation returns a Matrix (x,y,z,w), which is two Quaternions multiplied together.

Yes; it takes the resulting quaternion and converts it to a rotation matrix.

I'm guessing the * has been overloaded to support multiplying Quaternions?

Yes

The second part is a little difficult to understand. I can't find a resource to define what the translate method takes in and returns

It applies a translation component (the cameras position vector, mTranslation) to the input matrix (identity matrix in this case) and returns the result.

See GLM docs http://glm.g-truc.net/0.9.2/api/a00245.html#ga4683c446c8432476750ade56f2537397

Would mTranslation be the vector my camera was currently located at?

Exactly