## Using 3D Rotation Matrices in Practice By confuted
So, now that
you more or less
know how to rotate a point in any arbitrary manner in three dimensions,
generating matrices along the way, it's time to learn what you should
do with
each of these matrices. This tutorial will cover just that: the
world
matrix, and the camera matrix.First, a quick review of what you should know from reading other tutorials. A point will go through multiple transformations before it finally makes it to the screen. The point will start out in model
space. Model space is just that - the space in which the
model was
created. Then, once the model has been rotated and translated to
the
appropriate spot in the world, the point will be in world
space. When
all of the points are in world space, your Quake 4 level will be all
laid out
and full of monsters, but there is one more step that the points have
to take
in three dimensional space before they will be ready to be converted to
two
dimensional space and displayed on the screen. The points need to
all be
transformed into camera space, also known as view space.
In
a 3D game, instead of the camera moving around the world, the world
moves
around the camera, and the camera always stays at the origin. So,
when
you rotate the camera, you are really rotating the world
backwards. When
you move the camera, you're translating the world around you. A
matrix
will be built to represent this, and after this camera matrix
transforms the
world space points, they will be in camera space. It is then a
fairly
simple matter to convert them to screen space and display them on the
screen. Many APIs will do this stuff for you, but that's what is
going on
in the background and you'll need to understand it.The first thing that needs to happen to a point in model space is that it needs to be rotated while it is still in model space. Then, it will need to be translated (moved) into world space. It may also need to be scaled. This can all be done with one matrix. After you generate the matrix, it can be used to transform every point in a model into world space. You'll need to make a new one of these matrices for each model, though. This will be the "world matrix" and will be set many times each frame. The next thing that happens to a point is rotating and moving according to the camera's position and orientation. This can be a stumbling point for a lot of people. The first thing to remember is that the view matrix need be set only once per frame. All points will be transformed by it. Depending on what you need your camera to do, there are several different ways of generating it. Check your API documentation - chances are fairly strong that there will be a built-in way of generating a camera matrix by just passing a function a few vectors. Otherwise, there are numerous tutorials online for different methods of building this matrix. To convert a 3d point to a 2d point may seem to be a non-trivial matter. You are, in essence, attempting to project a three dimensional point onto the correct spot of a two dimensional plane. For points farther in the distance, you'll want to create a perspective illusion, and make all points converge to one point in the center of the screen. After all the math I've hit you with, you're probably preparing yourself for something even more complex. Wrong. The hard math doesn't come until the next tutorial. Just do this: Screen_X
= (viewSpace_X / viewSpace_Z)+(SCREEN_WIDTH/2) For a FPS, it's probably safe to do transformations with Euler angles when going from model space into world space. Chances are good that the monsters in your game will only be rotating about their Y-axis, in which case you're 100% safe with Euler angles. However, the camera will not be restricted like this. The camera will rotate on two, or possibly three axes, and thus will be subject to gimbal lock if you use Euler angles. So, for the camera, either use an axis-angle representation, or quaternions - the mind-blowing, really cool subject of the next tutorial. Previous: Rotation About an Arbitrary Axis Next: Using Quaternions Back to Graphics tutorials index |