Calculate camera LookAt position in 3 dimensions (DirectX) - c++

Question

I just started to learn DirectX. Currently I have a cube and a camera which I can move around the cube by sphere.
But now I want to create a feature so I can to turn my camera a bit (left/right/top/bottom). I easily understand how to make it in 2D: I can change X and Y in LookAt function and it's done. How can I do same thing but in 3D? There are 3 dimensions and my camera can take any angle...
I think I need to find a plane perpendicular to the camera vector and deal with it as with 2D. Image
Or I can do it more easy?

Answer 1

The view transformation is a tricky one. Usually, you have model transformations that e.g. move, rotate or scale objects (world transformations).
However, the view transformation is a system transformation. We could imagine it as a model transformation that moves the camera from its position to the origin. Of course, it is easier to look at the inverse view transformation. The one that places the camera at its position.
And that's what we're going to do. Let's say we have a transformation M that positions the camera. The according view transformation is its inverse: V = M^(-1). If you wanted to rotate the camera object, you would just multiply a rotation matrix to the model transformation:
M' = R * M
That would rotate the camera at its position after applying M. The according view transformation is still the inverse. Applying the inverse to M' yields
V' = (M')^(-1)
= (R * M)^(-1)
= M^(-1) * R^(-1)
We see that M^(-1) is the old view transformation. Therefore:
V' = V * R^(-1)
So if you want to rotate the camera, multiply a rotation matrix (with the negative angle) to the right of the current view matrix.
So the workflow would be the following:
At the beginning of the game, set up the view matrix with the LookAt method.
Each time the player rotates the camera, multiply a rotation matrix to the current view matrix. Make sure that the angles are not too big. If you rotate by 10° every frame, you already have 600* after a second at 60 fps.
Whenever you want to reset the camera, use the LookAt method again.
If you want to turn up and down, use XMMatrixRotationX. If you want to turn left and right, use XMMatrixRotationY. XMMatrixRotationZ would result in a roll.

Answer 2

For camera rotations, use the D3DXMatrixLookAtLH method. Your question is about how to calculate the desired 'at' or 'target' of the eye. This Vector3 is calculated using the same trig methods used in 2D, but just with an extra dimension. You'll need a Vector3 for rotation, each component of which will be rotation about that axis. Then use the below method to apply your rotations to your matrix created with the previously mentioned method.
To perform the same thing on objects in your world, use the DirectX method D3DXMatrixRotation(X,Y,Z) depending on your rotation direction. In a properly oriented world, left and right would rotate about the Y axis, up and down would rotate about the X axis, and tilting would be done about the Z axis. This is, of course, for matrix rotations, not Quaternions.
Remember when performing rotation (or any manipulative operation) to remember the order of operations (ISROT):
I dentity
S cale
R otation
O rbit
T ranslation
This way you don't end up having seemingly funky stuff happen. Also consider the D3DXMatrixYawPitchRoll method.

Answer 3

First, you should read this question.
Basically, matrix is a coordinate system that contains x, y, z vectors and position of the system (within coordinates of parent system). So you can tear the matrix apart, modify vectors, and rebuild the matrix again, without using any "LookAt" routines. The important thing, though, is that camera matrix (view transform) is an inverse of object matrix (world transform) if an object was placed instead of camera at this point. However, because camera matrix has special properties (axes are perpendicular and are norlmally unit-length), you can simply transpose it and recalculate "position" part of matrix.
This old function of mine will build camera matrix ("view" transform or D3DTS_VIEW) out of set of vectors. x points right, y points up, z points forward, and pos is a camera position.
typedef D3DXVECTOR3 Vector3;
typedef D3DXMATRIX Matrix;
void vecToCameraMat(Matrix& m, const Vector3& x, const Vector3& y, const Vector3& z, const Vector3& pos){
m._11 = x.x;
m._12 = y.x;
m._13 = z.x;
m._14 = 0;
m._21 = x.y;
m._22 = y.y;
m._23 = z.y;
m._24 = 0;
m._31 = x.z;
m._32 = y.z;
m._33 = z.z;
m._34 = 0;
m._41 = - (pos.x*x.x + pos.y*x.y + pos.z*x.z);//(pos.x*x.x + pos.y*y.x + pos.z*z.x);
m._42 = - (pos.x*y.x + pos.y*y.y + pos.z*y.z);
m._43 = - (pos.x*z.x + pos.y*z.y + pos.z*z.z);
m._44 = 1;
}
deconstruct camera matrix into vectors:
void cameraMatToVec(Vector3& x, Vector3& y, Vector3& z, Vector3& pos, const Matrix& m){
x.x = m._11;
y.x = m._12;
z.x = m._13;
x.y = m._21;
y.y = m._22;
z.y = m._23;
x.z = m._31;
y.z = m._32;
z.z = m._33;
pos.x = -(m._41*x.x + m._42*y.x + m._43*z.x);
pos.y = -(m._41*x.y + m._42*y.y + m._43*z.y);
pos.z = -(m._41*x.z + m._42*y.z + m._43*z.z);
}
And this will construct OBJECT matrix (i.e. "world" transform or D3DTS_WORLD) using similar set of vectors.
void vecToMat(Matrix& m, const Vector3& x, const Vector3& y, const Vector3& z, const Vector3& pos){
m._11 = x.x;
m._12 = x.y;
m._13 = x.z;
m._14 = 0;
m._21 = y.x;
m._22 = y.y;
m._23 = y.z;
m._24 = 0;
m._31 = z.x;
m._32 = z.y;
m._33 = z.z;
m._34 = 0;
m._41 = pos.x;
m._42 = pos.y;
m._43 = pos.z;
m._44 = 1;
}
deconstruct "object" matrix into set of vectors:
void matToVec(Vector3& x, Vector3& y, Vector3& z, Vector3& vpos, const Matrix& m){
x.x = m._11;
x.y = m._12;
x.z = m._13;
y.x = m._21;
y.y = m._22;
y.z = m._23;
z.x = m._31;
z.y = m._32;
z.z = m._33;
vpos.x = m._41;
vpos.y = m._42;
vpos.z = m._43;
}
For camera, x, y and z should have length of 1.0 and should be perpendicular to each other.
Those routines are DirectX-specific and assume that (view) matrices are left-handed.
To move camera to the "right", you need to break matrix into components, add "x" to "pos" and construct it again. If you insist on using "look at", then you'll have to add "x" to both "view position" and "look at position".