OK, that''s actually not so easy to explain without images, I''ll still try. Note that there are quicker methods to get the planes (most of them involving matrix extraction), but this is the basic, most understandable one.

I don''t know if you are familiar with the mathematical representation of a plane, and its relation to normals and space orientation. If not, I''ll quickly summarize it:

A 3D plane is mathemtically represented by the plane equation: Ax + By + Cz + D = 0. (A,B,C) are the three components of it''s (normalized) normal, D is the displacement offset along the normal. This equation simply states, that any point (x,y,z) that satisfies the equation (result is 0) will lie on that plane.

To cull geometry against a plane, you need the normal, and the D value. You can rewrite the equation in terms more familiar to a graphics programmer: N.x*P.x + N.y*P.y + N.z*P.z + D = 0. So first, you need to get N, the normal. A normal of a plane can be computed from three points that are guaranteed to lie on that plane. Let''s call them P1, P2 and P3. The normal N is now defined as the crossproduct of the differential vectors between P1,P2 and P1,P3:

U = P2-P1
V = P3-P1

N = U CROSS V
N = Normalize(N)

Now you have your normal. Next step is to get the D value. You use the plane equation for that: you have the normal, and you have a point on the plane (choose one of your P1 to P3). So, reorder your equation to have D on the left side, and you get:

D = -( N.x*P1.x + N.y*P1.y + N.z*P1.z )

That''s it.

Now, to build a frustum, you need 6 planes: the four side planes, the near camera and the far camera plane. The first 4 create a pyramidal structure that define the view frustum, and the later 2 define the minimum and maximum view distance. The near plane must always be infront of the camera, otherwise your geometry will flip around.

From the equations above, you''ll need 3 points to create a plane. Consider your view frustum: imagine a pyramid with it''s apex (top) at the camera position (x,y,z) and pointing into the direction (xa,ya,za). Let''s ignore the near and far planes for now. The 4 pyramid faces represent the four planes. The pyramid also has 4 edges, those edges can be represented by vectors and each edge vector is shared by two faces.

You already have your first plane vertex: the camera position. Since it is at the pyramid''s top, it is shared by all planes, thous is a valid point for all four frustum planes. To get the remaining 2 per plane, you''ll first need to calculate the 4 edge vectors. They all originate at the camera position, and go out into infinity along the four pyramid edges.

To obtain their direction, you have to take camera direction into account. But you also need two additional values: the horizontal and vertical FOV (field of view). Those values represent the opening angles of your pyramid planes: the vertical FOV is the angle from the bottom to the top plane (measured at the apex), the horizontal FOV is from the left to the right plane.

With those values, you can now compute the 4 edge vectors (that are actually direction rays) using basic trigonometry. To finally get hold of your plane points, just pick an arbitrary distance, and compute the 3D point along all four edge vectors at that distance. Now each of those four points is shared by two planes. The last step is to use the correct 3 points per plane (the camera position, and the two corresponding points from the edge vectors), and plug them into the plane equation above.

The near and far plane are computed in a little different way. In both cases, their normal is simply the vector formed by your camera rotation (xa,ya,za): Transform this rotation into a normalized vector, and you have your near-plane normal. Flip it, and you have the far plane.

/ Yann

No, that will not work. Your 3 direction values are angles, not vector components.

But it''s a good idea to start with the near plane. To get the normal, you need to create a unit vector in the origin direction of the camera. IE: it must point into the direction (in 3D space) the camera would be looking into, if all three values (xa,ya,za) are zero. The length has no importance here, it will be renormalized later anyway (to compensate for floating point precision problems). Now, you get the normal of the near plane, by rotating this vector by INV(xa,ya,za). That part is important: you basically transform the direction vector into the camera''s new coordinate system. The INV() infront of the angles denote inversion: you need to rotate the plane by the inverse of the angles. This is done to compensate for the two different coordinate frames encountered: your camera and the world around you. Think about it: if your camera turns right, then the world around actually turns left. The rotation is inverted. BTW, when using matrix transforms, then this is typically done by transposing the matrix.

Once you have your new inversly rotated normal, you should renormalize it. It is then ready to be used as normal for the near clipping plane.