The purpose of this tutorial is to show an alternative to representing 3D environments in Flash. The method that is most popular and easiest to do is rotating about the x-, y-, and z-axes. The equations for these operations can be derived in a multitude of ways, but this tutorial will assume you already know how to use them. However, the equations will be used very little in this tutorial because they are not all that important in what we will be covering.
What is a Camera?
For this tutorial a camera is going to be a viewing system to see your 3D environment through. You would specify the camera's position and orientation (direction it is looking and 'spin' of the camera), and from that you would derive a rotation matrix that would transform the points in your environment to their position how they appear to the camera. The concept of a matrix and rotation matrix will be developed later in this tutorial. By the end of this tutorial you will be able to see what the box in the picture below looks like to the camera.
Using a camera in a 3D environment is magnitudes more powerful than rotating about the coordinate axes. Using a camera adds flexibility to navigating a 3D world. When using a camera you would keep the position of all the points in your environment fixed and simply move the camera through the world. While moving in a straight line you could easily rotate the camera around to see how your world looks from different positions, or you could simulate a 1st person perspective by moving the camera in the direction it is facing. These are all very difficult tasks to complete by rotating a world about the x-, y-, and z-axis, if not impossible.
Rotation about the Coordinate Axes and an Arbitrary Axis
Although not the focus of this tutorial, and not even used very much, the equations for rotations around axes should be shown. The derivations and thought process of the equations has been left out since this is simply background information.
Rotations around the coordinate axes are the easiest. They can be derived using the sum identity for sine and cosine. Given the ordered triplet (x, y, z) and a rotation angle of q, the rotated ordered triplet (x', y', z') can be found with the following equations:
Rotation about the x-axisAn important property to take note of is that a rotation around a certain axis does not affect the value of the axis' coordinate. For example, you rotate around the x-axis but the x-coordinate was not affected. Same goes for the y- and z-axis. This has to do with the fact that the axis at which you rotate about is an eigenvector of the rotation matrix formed. An eigenvector is a vector associated with a square matrix that when multiplied with the matrix it does not change in direction, but only in magnitude (and sometimes not even magnitude). The notion of an eigenvector will not be discussed in this tutorial, but it is still a very important and interesting subject if you wish to explore it on your own.
x' = x
y' = y cos q - z sin q
z' = y sin q + z cos q
Rotation about the y-axis
x' = x cos q + z sin q
y' = y
z' = -x sin q + z cos q
Rotation abut the z-axis
x' = x cos q - y sin q
y' = x sin q + y cos q
z' = z
A much more useful method for rotation is the rotation about an arbitrary axis. What if you wanted to rotate around the axis that points from (0, 0, 0) to (2, 1, 3) rather than the coordinate axes. We are going to write the equation in its vector form first. We define x to be the current position of the point to be rotated, a to be the axis the point will rotate about, q to be the angle of rotation, and x' to be the rotated point. The three quantities x, x', and a are all vectors. For the equation to work a must also be a unit vector. If you are unsure of the terminology being used make sure to read the vector tutorial on this site first.
x' = p cos q + (a ´ p) sin q + a (a · p) (1 - cos q)Although quit a long equation it can be implemented easily. Remember that the ´ operator is the cross product and it returns a vector, and the · operator is the dot product and it returns a scalar. Later on we will organize these messy equations into simple rotation matrices.
Linear Algebra
By far the most important subject when studying 3D is linear algebra. Linear algebra is most likely called 'linear' because the entire subject starts off with a systematic way of solving linear systems of equations. When looking to organize many equations containing many unknowns, brilliant mathematicians put the coefficients of the equations in one matrix, the variables in another matrix, and the solution to the equations in yet another matrix. You were then left with one equation that simply had matrices in it, which is just another mathematical object like a vector or scalar. The problem seemed less intimidating now and thus flourished linear algebra. Of course the once-upon-a-time connotation is not fully accurate, but ultimately the subject came about when mathematicians were faced with solving systems of linear equations.
Matrices
We have already learned of one mathematical object used in linear algebra: the vector. The next important object is the matrix. A matrix is a set of numbers arranged in a rectangular array. A matrix is two dimensional because it has rows and columns. The only size matrix we will be using is three by three and three by one matrices. They look something like this:
/ e11 e12 e13 \
M = | e21 e22 e23 |
\ e31 e32 e33 /
/ e11 \
M = | e21 |
\ e31 /
The notation of a matrix for us will be an upper-case bold letter, whereas
a vector was a lower-case bold letter, and a scalar was a lower-case italic
letter. To reference an element in a matrix we will use the notation 'e12'
meaning the element in the 1st row and 2nd column.There are only a few operations that we will be concerned with that can be done to matrices: multiplication, inversion, and transposition. Multiplication and transposition will be covered now, but inversion will be covered later. Let us first deal with multiplication because that is what will be used the most.
There are three types of multiplication that we are going to deal with. Multiplying a matrix with a scalar, multiplying a matrix with a vector, and multiplying two matrices. Multiplying a matrix with a scalar is by far the easiest operation. You simply multiply every element in the matrix with the scalar.
/ e11 e12 e13 \
M = | e21 e22 e23 |
\ e31 e32 e33 /
/ e11 e12 e13 \ / s*e11 s*e12 s*e13 \
s M = s | e21 e22 e23 | = | s*e21 s*e22 s*e23 |
\ e31 e32 e33 / \ s*e31 s*e32 s*e33 /
Multiplying a matrix and a vector together is a little bit trickier. Although
matrix-vector multiplication are not exactly defined, we can imagine that
the vector is simply a three by one matrix. Also, the product of a matrix
and vector is another vector, or three by one matrix depending on how you
look at it. The first thing to do is write out the problem:
/ m11 m12 m13 \
M = | m21 m22 m23 |
\ m31 m32 m33 /
/ v11 \
V = | v21 |
\ v31 /
/ m11 m12 m13 \ / v11 \
M V = | m21 m22 m23 | | v21 |
\ m31 m32 m33 / \ v31 /
To find the resulting vector from the above multiplication you multiply
the column matrix (the vector) with every row of the three by three matrix.
When you multiply the vector with the first row of the three by three matrix
you get the first element of the resulting vector, when you multiply the
vector with the second row you get the second element, and so on. Performing
the multiplication above gives you the following vector:
/ v11 * m11 + v21 * m12 + v31 * m13 \
M V = | v11 * m21 + v21 * m22 + v31 * m23 |
\ v11 * m31 + v21 * m32 + v31 * m33 /
The same thing can be done with two dimensional vectors and two by two matrices.
/ m11 m12 \
M = \ m21 m22 /
/ v11 \
V = \ v21 /
/ m11 m12 \ / v11 \ / v11 * m11 + v21 * m12 \
M V = \ m21 m22 / \ v21 / = \ v11 * m21 + v21 * m22 /
Multiply two matrices together is even trickier. To multiply matrix A
and B together you must multiply every row of A with every
column of B. The product of two 3x3 matrices is another 3x3 matrix,
and the product of two 2x2 matrices is another 2x2 matrix. To drive this
home in the simplest way here is how you would multiply two 2x2 matrices:
/ a11 a12 \
A = \ a21 a22 /
/ b11 b12 \
B = \ b21 b22 /
/ b11*a11 + b21*a12 b12*a11 + b22*a12 \
AB = \ b11*a21 + b21*a22 b12*a21 + b22*a22 /
The best way to remember this is to treat B like a vector. If you
simply neglect the second column and only look at the first (a vector since
it is only a column matrix) then the first column of the product is the
same as if you were multiplying a matrix and a vector together. Once you
have the first column of the product matrix you can find the second column
by neglecting the first column of B and only looking at the second
(once again a vector). Multiplying A with that vector will give you
the second column of the product matrix, and then you are done.Multiplying two 3x3 matrices is the same except now you have to do the vector multiplication method three times, once for each column. Because there are so many elements to multiply for the product matrix each element of the product is going to be referenced as AB.e11, AB.e12, and so on. The general product matrix looks like this:
/ a11 a12 a13 \ A = | a21 a22 a23 |That may seem somewhat cumbersome to memorize so I would not even recommend it. You can always reference this page or anything else so just know what matrix multiplication is, and what dimension matrices are formed from multiplying a matrix with a scalar, vector, or another matrix.
\ a31 a32 a33 / / b11 b12 b13 \ B = | b21 b22 b23 |
\ b31 b32 b33 / AB.e11 = b11 * a11 + b21 * a12 + b31 * a13
AB.e12 = b12 * a11 + b22 * a12 + b32 * a13 AB.e13 = b13 * a11 + b23 * a12 + b33 * a13 AB.e21 = b11 * a21 + b21 * a22 + b31 * a23
AB.e22 = b12 * a21 + b22 * a22 + b32 * a23 AB.e23 = b13 * a21 + b23 * a22 + b33 * a23 AB.e31 = b11 * a31 + b21 * a32 + b31 * a33
AB.e32 = b12 * a31 + b22 * a32 + b32 * a33 AB.e33 = b13 * a31 + b23 * a32 + b33 * a33
The transposition of a 3x3 matrix results in a matrix with the exact same dimensions and elements except with a permutation of the elements. Basically, you switch the eij (where i and j can be any number within the dimensions of the matrix) with the eji element. For example, in a 2x2 matrix the e11 and e22 elements stay the same (since i = j), but the e12 element is switched to e21 and vice versa.
/ m11 m12 \ M = \ m21 m22 /Take note that the transposition matrix is denoted with a superscript T. The transpose of a 3x3 matrix is nearly the same:
/ m11 m21 \
MT = \ m12 m22 /
/ m11 m12 m13 \
M = | m21 m22 m23 |
\ m31 m32 m33 /
/ m11 m21 m31 \
MT = | m12 m22 m32 |
\ m13 m23 m33 /
Transposition is a very simple operation and will be very powerful later
on.Special Types of Matrices
If you were to multiply two matrices, A and B, together and the product was A, B would be called an identity matrix. An identity matrix is a matrix that does not change another matrix when they are multiplied together. Such a matrix is always denoted with I and looks like this:
/ 1 0 0 \ I = | 0 1 0 |And you can do away with the third row and column to get the 2x2 identity matrix equivalent. To show that the above is really the identity matrix we can multiply it will a general 3x3 matrix:
\ 0 0 1 /
/ a11 a12 a13 \ A = | a21 a22 a23 |Before we go on to another type of special matrix we are going to cover inversion of matrices briefly. Inverses of matrices is a very important operation in linear algebra. The reason why we are only briefly covering them will be known in a moment.
\ a31 a32 a33 / / 1 0 0 \ B = | 0 1 0 |
\ 0 0 1 / AB.e11 = 1 * a11 + 0 * a12 + 0 * a13
AB.e12 = 0 * a11 + 1 * a12 + 0 * a13 AB.e13 = 0 * a11 + 0 * a12 + 1 * a13 AB.e21 = 1 * a21 + 0 * a22 + 0 * a23
AB.e22 = 0 * a21 + 1 * a22 + 0 * a23 AB.e23 = 0 * a21 + 0 * a22 + 1 * a23 AB.e31 = 1 * a31 + 0 * a32 + 0 * a33
AB.e32 = 0 * a31 + 1 * a32 + 0 * a33 AB.e33 = 0 * a31 + 0 * a32 + 1 * a33 -- which reduces down to -- AB.e11 = a11
AB.e12 = a12 AB.e13 = a13 AB.e21 = a21
AB.e22 = a22 AB.e23 = a23 AB.e31 = a31 AB.e32 = a32 AB.e33 = a33
If you had a matrix, named A, the inverse of A would be such that when you multiplied the two together the product would be the identity matrix. Like this:
A-1 A = ITake note that the inverse matrix is denoted with a superscript negative one. We are not going to discuss all the general methods of solving such a problem because that could easily add another fifty pages to this simple tutorial. However, we are going to find a way to get the inverse of a special type of matrices with a very easy operation soon.
The next special type of matrix we are going to look at are orthonormal matrices. To show what an orthonormal matrix is we are going to first associate each row of a matrix with a vector. Therefore, a 2x2 matrix is made up of two vectors and a 3x3 matrix is made up of three vectors:
a = < a1, a1, a3 >
b = < b1, b2, b3 >
c = < c1, c2, c3 >
/ a1 a2 a3 \
M = | b1 b2 b3 |
\ c1 c2 c3 /
Given the above vectors and matrix, M can only be an orthonormal
matrix if a, b, and c are unit vectors and if the dot
product of each vector with each other vector is zero. Remember that zero
for a dot product meant that the two vectors were perpendicular. Therefore
an orthonormal matrix also means that the vectors a, b, and
c are unit vectors and perpendicular. Also know that if we took the
vectors a, b, and c to be the columns of the matrix
rather than the rows, the test for whether a matrix was orthonormal or not
would still hold, as will be shown now.A very important property of orthonormal matrices is that their transpose is equal to their inverse. Meaning that you can find the inverse of an orthonormal matrix by simply taking its transpose.
MT = M-1Usually inverting a matrix is a slow, CPU-intensive computation, but transposition is easily done and rather fast. The inverse of an orthonormal matrix is yet another orthonormal matrix. This is why it does not matter if you use the vectors as the rows or columns and the test for an orthonormal matrix still holds.
Another important property of orthonoraml matrices that the product of any two orthonormal matrices is another orthonormal matrix. This simple property will actually help you save CPU calculations, as you will see in the next section on rotation matrices.
Rotation Matrices
A rotation matrix is simply another name for an orthonormal matrix. If you multiply a vector (column matrix) by an orthonormal matrix you will perform some type of rotation on the vector (except for the trivial case of the identity matrix which does not perform any transformation). The very important link between why a rotation matrix and an orthonormal matrix are the same will be shown later.
For right now we are going to simply convert the equations that we came up with before for rotating a point around the x-, y-, and z-axis and an arbitrary axis into rotation matrices. Let us first start with a general rotation matrix and vector and see if we can find the appropriate values:
/ r11 r12 r13 \
R = | r21 r22 r23 |
\ r31 r32 r33 /
v = < v1, v2, v3 >
Let us quickly look back at what the equations looked like for a rotation
around the x-axis and see if we can find the values of the rotation matrix:
Rotation about the x-axisBy looking at the above equations it would seem that the first row of the rotation matrix would be similar to the identity matrix since the x-component of the vector is unchanged. In fact, the first column would be part of the identity matrix too because the x-component does not show up anywhere in the calculation of the y- and z-component of the rotation vector. Then, only four elements of the 3x3 matrix are left to speculation, but those can been easily shown to come out like this:
x' = x
y' = y cos q - z sin q
z' = y sin q + z cos q
/ 1 0 0 \
Rx = | 0 cos q -sin q |
\ 0 sin q cos q /
Multiply the above with vector v gives you the following (to make
it easier to read the vector is represented as a column matrix):
/ x \
v' = Rx v = | y cos q - z sin q |
\ y sin q + z cos q /
Without discussing them as much as the x-axis rotation matrix, the rotation
matrices for the y- and z-axis can be expressed as follows:
/ cos q 0 sin q \
Ry = | 0 1 0 |
\ -sin q 0 cos q /
/ cos q -sin q 0 \
Rz = | sin q cos q 0 |
\ 0 0 1 /
It is slightly harder to come up with a rotation matrix for an arbitrary
axis so it will not be complete shown. In fact, it takes a few 'far from
common sense' steps to arrive at the matrix. For example, someone had the
cleverness to substitute a cross product with a skew-symmetric matrix (a
skew-symmetric matrix is one in which its transpose is equal to itself multiplied
by the scalar negative one). The matrix looks like this (q
is the rotation angle and a is the axis of rotation):
c = cos q s = sin q t = 1 - cos qNow, from what we know about orthonormal matrices, their properties, and their relationship to rotation matrices, we can now discuss some very useful applications to three dimensional programming.
a = < x, y, z > / tx2 + c txy - sz txz + sy \ Ra = | txy + sz ty2 + c tyz - sx | \ txz - sy tyz + sx tz2 + c /
Let us say you have a rotation matrix for rotations about the x-axis. Every frame you multiply a point's position by this matrix, you update the position of the point, and you render it on the screen. What would happen if you rotated by an q, and then you want to undo that angle by rotating back to your old position? Your first instinct may be to simply construct a new rotation matrix with a negative q and then multiply point with that matrix. However, if you could find an inverse of the rotation matrix, a multiplication of that matrix with the point's position would simply undo the rotation and put it back in its original position (since a matrix and its inverse multiplied together produce an identity matrix). Then from what you know about orthonormal matrices you can easily find the inverse matrix without doing any addition sine or cosine calculations. The inverse of the four rotation matrices above are:
/ 1 0 0 \
RxT = | 0 cos q sin q |
\ 0 -sin q cos q /
/ cos q 0 -sin q \
RyT = | 0 1 0 |
\ sin q 0 cos q /
/ cos q sin q 0 \
RzT = | -sin q cos q 0 |
\ 0 0 1 /
/ tx2 + c txy + sz txz - sy \
RaT = | txy - sz ty2 + c tyz + sx |
\ txz + sy tyz - sx tz2 + c /
Notice that the inverse of the rotation matrices only differ by a sign
change here and there from their original form.
Another application of what we have learned is employed heavily by most
of the major 3D graphics API's like OpenGL. Since the product of two orthonormal
matrices is another orthonormal matrix you can simply concatenate many
rotation matrices together to get your final rotation matrix. For example,
if you were to do a rotation about the x-axis and then the y-axis you
might have taken the point's position (x, y, z) and plugged it into the
x-axis rotation equations to get the new position of the point. Then you
plugged that new position into the y-axis rotation equations to get the
final position of the point. However, we could do that exact same thing
with matrices and eliminate a few of the arithmetic operations. If we
get the rotation matrices for the x- and y-axis we can simply multiply
those two together to get another rotation matrix, and finally multiply
the point with that matrix to get its position after being rotated around
the x- and y-axis.
This concept of concatenating matrices is used in OpenGL and DirectX.
There is a main 4x4 matrix (most API's use 4x4 matrices because they use
homogenous coordinates which was not discussed in this tutorial) that
all points set through the API are multiplied by; this matrix starts off
as the identity. Then, the user can perform rotations of the 3D environment
through the use of a function, glRotatef (angle, axis_x, axis_y, axis_z)
for OpenGL. This function multiplies the rotation matrix you specify with
the current rotation matrix in the system. You can do this over and over,
performing many rotations about tons of different axes and the matrix
still stays orthonormal and remains a rotation matrix. Then at the end
the points are multiplied by the final rotation matrix and they are rotated.
All of this saves calculations because in the end you are multiplying
the points with only one rotation matrix; you could concatenate ten rotation
matrices into one. Quite a powerful property of orthonormal matrices.
The Basics of a Basis
Much of linear algebra leads up to the very important concept of a basis.
A complete detail of bases requires knowledge of many things like vector
spaces, subspaces, linear combinations, linear dependence (independence),
and more that is probably too conceptual to be of any interest for what
our ultimate goal is. Therefore much of what linear algebra covers is
going to be left out or watered down thoroughly.
To make visualization of a basis easier we will only be dealing with two
dimensions, which means 2x2 matrices and vectors with only two components
(two by one matrices). The concepts will be developed for three dimensions
too (because it is essential to understanding cameras), but it is just
harder to visualize.
A basis can be thought of as a set of vectors that define a coordinate
system; specifically it is a matrix where its elements are made up of
the vectors that defined the coordinate system. In applications to the
real world it is sometimes to define a different coordinate system to
work in other than the Cartesian x- and y-axis. In Special Relativity
you deal with coordinate systems and inertial frames thoroughly. For us,
bases are going to provide a simple way of changing between coordinate
systems.
We learned in the vector tutorial that the unit vectors i and j
were special vectors that point in the directions of the x- and y-axis
respectively. These two vectors define what is called the standard basis.
In matrix form you would put the components of i in the first column
and the components of j in the second column. It would look like
this:
i j
/ 1 0 \
S = \ 0 1 /
Let us say we wanted to define a coordinate system that differed a little
from the standard basis. The x-axis vector will now be <2, 1> and
the y-axis will be <0, 3>. This new basis would look like this as
a matrix:
/ 2 0 \ B = \ 1 3 /And that is all there is to constructing a basis. You can do the same for three dimensions. This is what the standard basis looks like for three axes:
i j k
/ 1 0 0 \
S = | 0 1 0 |
\ 0 0 1 /
It is also useful to visualize the different coordinate systems.
The white lines represents the standard basis while the blue lines represents
some arbitrary basis. If you were to print that picture out and plot a
point at (2, 1) relative to the white lines it would approximately be
the equivalent to the point (1.2, .1) relative to the blue lines. This
brings up an important question: how can we find the position of a point
in one coordinate system relative to another coordinate system? This is
the fundamental problem that we will use bases to solve.
To illustrate this problem in a more useful situtation let us look at
another coordinate system: one that differs from the standard basis by
a rotation of the angle q. Such a coordinate
system looks like this:
Now, how can we come up with a general method of finding the coordinate of a point in the standard basis from knowing its position in an arbitrary basis (since we see that it can be very useful)? This is the rather easy part. Simply write out the matrix form of the basis and multiply the position of the point in that basis with the matrix. That will give you the point in the standard basis. For example, let us take the basis that we were dealing with before. We will call the x-axis vector v, where v = <2, 1>, and call the y-axis vector w, where w = <0, 3>. What would the position of the point (4, 2) relative to this new basis be in the standar basis? Here is the work (B is the basis matrix, p is the vector position of the point in B, and p' is the vector position of the point in the standard basis, S):
v w
/ 2 0 \
B = \ 1 3 /
p = < 4, 2 >
/ 2 0 \ / 4 \
p' = \ 1 3 / \ 2 /
/ 8 \
= \ 10 /
Now the basis just shown is not very useful because such a skewed arbitrary
matrix does not represent all that much. The bases we will be most concerned
with are going to be ones that differ from the standard basis by an angle
of q like shown before. For these types of bases
to work you must maintain two important properties of the vectors used:
the vectors of the axes must be unit vectors and all the vectors must be
orthogonal. In short, the basis matrix must be an orthonormal matrix. We can come up with such a basis in two dimensions easily by remembering that the x-component of a unit vector is the cosine of the angle of the vector, and that the y-component of a unit vector is the sine of the angle. This means that already we know the x-axis vector of our new basis: v = < cos q, sin q >. To get a vector that is perpendicular to that vector we just remember a simple rule from algebra. The slope of a line is the change in y divided by the change in x: m = y / x. To get the value of a slope perpendicular to that you take the reciprocal (swap the numerator and denominator) and multiply the numerator by negative one: m^ = -x / y. We can use this same concept to construct and orthogonal vector. Here y is sin q and x is cos q, therefore the perpendicular vector, and happens to be the y-axis of the coordinate system, is: w = <-sin q, cos q>. Finally, the basis of the rotated coordinate system is:
/ cos q -sin q \ B = \ sin q cos q /Now, if you know a point in the basis B, and you want to find its position in the standard basis, you can multiply it by that matrix. Or, in less mathematical terms, to rotate a point by an angle of q multiply it with the above matrix. Also, if you look closely you will see the above matrix is the exact same as the rotation matrix for about the z-axis. In fact, all the rotation matrices shown earlier are simply bases, each one differing from the standard basis by a mere angle. Before, you thought of it as rotating a point about the different axes with a few equations; now you can think of it as finding the position of a point in the standard basis from its position in a rotated coordinate system.
Application to the Camera
It is now time to relate the massive amount of information to what we wanted to do originally: develop a camera in Flash. In terms of what we have learned so far, what would best represent a camera? The answer is a basis. A camera is a coordinate system all of its own, where each axis is perpendicular to each other. It has an axis shooting out of the lens, an axis coming out of the top, and an axis out to the side. We are going to give some names to these vectors that will be used from now on: the axis coming out of the side of the camera is going to be the side vector, the vector coming out of the top is going to be the up vector, and the one pointing in the direction the camera is facing is going to be the out vector. Remember that all the axes must be unit vectors.
There is one difference in the bases that we talked about earlier and the basis of a camera. Before, all the bases we discussed shared the same point for the origin. This time, however, the bases will not since the camera can move anywhere in a 3D environment. In the following picture we have the point (x, y, z) relative to the origin being at (0, 0, 0). We also have a camera placed at (a, b, c).
Now we will derive the rotation matrix to apply to the vectors pointing from the camera to the points in the standard basis; this will complete the transformation and the points will finally be in the camera's coordinate system, ready to render. Your first instinct may be to simply put the components of the vectors into the columns of the rotation matrix. However, there is a little bit more that you need to do. Before, when dealing with bases, we were going from an arbitrary basis to the standard basis. This time, however, we are going from the standard basis to the camera's basis. This means an inverse transformation must be done, thus you simply take the inverse of the camera's basis for the final rotation matrix.
Although it may be hard to believe, you have learned everything you need to know about cameras. After covering all of the mathematics only a few things needed to be stated about cameras. Here is a quick reference of the steps taken to view an environment through a camera.
1.) Position all the points in your environment relative
to the x-, y-, and z-axis.
2.) Position the camera somewhere out in space at (a, b, c).
3.) Define the camera's coordinate axis vectors: side, up, out.
4.) Make sure the camera's axes are orthogonal and unit vectors.
5.) Loop through every point in the environment and subtract
the camera's position vector <a, b, c> from the point's
position vector <x, y, z> and store it in a temporary variable.
6.) Create the rotation matrix from the camera's axis vectors:
side = < Sx, Sy, Sz >
up = < Ux, Uy, Uz >
out = < Ox, Oy, Oz >
[ Sx Sy Sz ]
R = [ Ux Uy Uz ]
[ Ox Oy Oz ]
7.) Multiply the temporary position vector of the point by the
above matrix.
8.) Render the tranformed point.
The CodeI have provided a starting point for you to use a camera with three classes for vectors, matrices, and cameras. The classes are fully documented so you should read them just as you read this tutorial. Practice using them for a little while, see how I coded it, and I think you will find they are very easy to use. You may even want to write your own if you think of a better way to do things.
When viewing the demo file provided remember that this is not the usually rotation about the coordinate axes. It is as if you were a camera man for a television show and you can move the camera around and rotate it to view everything from different angles. It may take a second to see what is going on, but I can guarantee that it is much easier to use, faster, and many times easier to control. In the demo the arrow keys control the orientation of the camera. The up and down arrows rotate the camera about its side axis, and the left and right arrows rotate about the world y-axis. The world y-axis is used because it is a much more natural feeling. If you were developing a flight simulator you would use the camera's up vector because it would rotate around that. The W and S keys translate the camera in the direction of the out vector, the A and D keys translate in the direction of the side vector, and the Q and E keys elevate the camera up and down.
Good luck.