Camera view matrix from position/yaw/pitch/worldUp

Question

I'm trying to make a basic FPS camera view matrix, using position, pitch/yaw, and worldUp. Currently, my camera's view matrix is just a plain rotation matrix (made with yaw/pitch/roll) and the result is the view appears to be looking down the negative Z-axis, which in my case is my floor. Most tutorials I can find recommend making a view matrix by passing in an "eye" and "target" vector. But this isn't a desirable setup for an FPS camera where I only know the position and angles (pitch/yaw/roll) of the camera -- I don't have a specific point in mind that I want the camera to be focused on!

I'm using OpenGL as a renderer, but I don't want to use GLM as I'd wish/hope to understand how to implement this without helper libs. Also, my meshes and world matrices are made so that Z is my worldUp, X as forward, and Y as right/left. That might seem odd, but old Unreal engine games used this setup and I'm just accustomed to it for mapping/modding.

As mentioned my view matrix is currently looking down at the floor, but I'm not surprised that it's wrong because I've never incorporated or multiplied my worldUp vector into the matrix, and I don't understand how to.

So that's my question: How exactly do I incorporate my worldUp vector into my rotation matrix, to turn it into a proper view matrix -- or better yet, what is the proper method for constructing a view matrix when you have exactly these variables: 1.) Camera Position (XYZ) 2.) World Up vector ("0,0,1" for me) 3.) Camera Pitch/Yaw/Roll (Really only need Pitch/Yaw!)

I've been going through loads of tutorials and I can't find what I'm looking for. This is how I've started, but all it is is a normal rotation matrix, so honestly a full methodology would be really appreciated as I've been pulling my hair out over this for a week now. Thank you for any guidance on this.

MAT4X4F mrol;
MAT4X4F mpit;
MAT4X4F myaw;
float cr, cp, cy;
float sr, sp, sy;

cr = cos(_cam_roll);    cp = cos(_cam_pitch);   cy = cos(_cam_yaw);
sr = sin(_cam_roll);    sp = sin(_cam_pitch);   sy = sin(_cam_yaw);

// Yaw (about Z-axis)
myaw.m[0] = cy;     myaw.m[1] = -sy;    myaw.m[2] = 0.0f;   myaw.m[3] = 0.0f;
myaw.m[4] = sy;     myaw.m[5] = cy;     myaw.m[6] = 0.0f;   myaw.m[7] = 0.0f;
myaw.m[8] = 0.0f;   myaw.m[9] = 0.0f;   myaw.m[10] = 1.0f;  myaw.m[11] = 0.0f;
myaw.m[12] = 0.0f;  myaw.m[13] = 0.0f;  myaw.m[14] = 0.0f;  myaw.m[15] = 1.0f;

// Pitch (about Y-axis)
mpit.m[0] = cp;     mpit.m[1] = 0.0f;   mpit.m[2] = sp;     mpit.m[3] = 0.0f;
mpit.m[4] = 0.0f;   mpit.m[5] = 1.0f;   mpit.m[6] = 0.0f;   mpit.m[7] = 0.0f;
mpit.m[8] = -sp;    mpit.m[9] = 0.0f;   mpit.m[10] = cp;    mpit.m[11] = 0.0f;
mpit.m[12] = 0.0f;  mpit.m[13] = 0.0f;  mpit.m[14] = 0.0f;  mpit.m[15] = 1.0f;

// Roll (about X-axis)
mrol.m[0] = 1.0f;   mrol.m[1] = 0.0f;   mrol.m[2] = 0.0f;   mrol.m[3] = 0.0f;
mrol.m[4] = 0.0f;   mrol.m[5] = cr;     mrol.m[6] = -sr;    mrol.m[7] = 0.0f;
mrol.m[8] = 0.0f;   mrol.m[9] = sr;     mrol.m[10] = cr;    mrol.m[11] = 0.0f;
mrol.m[12] = 0.0f;  mrol.m[13] = 0.0f;  mrol.m[14] = 0.0f;  mrol.m[15] = 1.0f;

_cam_matrix = myaw * mpit * mrol;

Answer 1

If you're transforming a vector \$\vec v\$ like this:

$$\vec v ' = M \cdot \vec v\\ \begin{bmatrix}v_x'\\v_y'\\v_z'\\1\end{bmatrix}= \begin{bmatrix}X_x & Y_x & Z_x &T_x\\ X_y & Y_y & Z_y & T_y\\ X_z & Y_z & Z_z & T_z \\ 0 & 0& 0 & 1 \end{bmatrix} \cdot \begin{bmatrix} v_x\\v_y\\v_z\\1 \end{bmatrix}$$

Then we can usefully think of each column of the matrix as a vector:

• \$\vec X\$ is the direction into which the x-axis basis vector (1, 0, 0, 0) gets transformed
• \$\vec Y\$ is the direction into which the y-axis basis vector (0, 1, 0, 0) gets transformed
• \$\vec Z\$ is the direction into which the z-axis basis vector (0, 0, 1, 0) gets transformed
• \$\vec T\$ is the position to which the local origin (0, 0, 0, 1) gets translated

If your multiplication convention is the opposite (\$\vec v \cdot M\$ - I can't remember what order OpenGL functions assume), then take the transpose of everything above - the columns become rows instead, but the same logic applies.

So, that makes it easy to compute a matrix with any orientation and any translation we want.

If we want the local x axis "forward" to point along a given yaw & pitch angle, we can compute the column vector \$\vec X\$ with spherical coordinates:

$$\vec X = \begin{bmatrix}\cos(pitch) \cdot \cos(yaw)\\ \cos(pitch) \cdot \sin(yaw)\\ \sin(pitch) \end{bmatrix}$$

(Negate the \$\sin\$ terms if you want the rotation direction to be opposite what's shown here)

If the local y axis points "right," then that depends only on yaw, no pitch needed:

$$\vec Y = \begin{bmatrix}-\sin(yaw)\\\cos(yaw)\\0\end{bmatrix}$$

And then the local z axis is just the cross product of the two:

$$\vec Z = \begin{bmatrix}- \sin (pitch) \cdot \cos (yaw) \\ - \sin (pitch) \cdot \sin (yaw) \\ \cos (pitch) \end{bmatrix}$$

And of course, \$ \vec T \$ is just the position of your camera.

To ultimately use this to render, you'll want to invert it (to transform world coordinates into camera-local coordinates), and swizzle the axes by swapping the rows around (since for drawing we typically want depth along the negative z axis, and height along the y axis)

So your view matrix would ultimately look something like this:

$$\begin{bmatrix} -\sin(y) & \cos(y) & 0 & T_x \sin(y) - T_y \cos(y)\\ -\sin(p) \cos(y) & -\sin(p) \sin(y) & \cos(p) & \sin(p)\left(T_x \cos(y) + T_y \sin(y)\right) - T_z \cos(p)\\ -\cos(p) \cos(y) & -\cos(p) \sin(y) & -\sin(p) & cos(p)\left(T_x \cos(y) + T_y \sin(y)\right) + T_z \sin(p) \\ 0 & 0 & 0 & 1 \end{bmatrix}$$