Jump to content
  • Advertisement


This topic is now archived and is closed to further replies.


Calculating a Frustum

This topic is 6626 days old which is more than the 365 day threshold we allow for new replies. Please post a new topic.

If you intended to correct an error in the post then please contact us.

Recommended Posts

Im having problems calculating the planes for a viewing frustum given a camera''s position and oreintation. Any websites on the matter? or can someone give me some ideas? thanks.

Share this post

Link to post
Share on other sites
Guest Anonymous Poster

I got this out of an OpenGL program I''ve downloaded somewhere. I don''t use
it because I use DX, but it might prove useful. I plan on using frustrum
planes myself sometime in the future:

struct PlaneInfo {
vector Normal;
float D;

void Set(float nx, float ny, float nz, float d) {
Normal.SetXYZ(nx, ny, nz);
D = d;
static PlaneInfo FrustumPlane[6];
static PlaneInfo TransformedFrustumPlane[6];

void DisplayReshape(int w, int h)
// Called when window changes dimensions. Set up viewport & projection matrix.

glViewport(0, 0, w, h);


// Set up projection matrix.

// This is slightly non-standard, since I prefer right-handed view coordinates, while
// OpenGL defaults to a left-handed system.


float nearz = 4.0;
float farz = 80000;

float AspectRatio = float(h) / float(w);
float ViewAngleH = 90 * (PI / 180);
float ViewAngleV = atan(tan(ViewAngleH/2) * AspectRatio) * 2;


float m[16];
int i;
for (i = 0; i < 16; i++) m<i> = 0;
m[0] = -1.0 / tan(ViewAngleH / 2);
m[5] = -m[0] / AspectRatio;
m[10] = (farz + nearz) / (farz - nearz);
m[11] = 1;
m[14] = - 2 * farz * nearz / (farz - nearz);



// Compute values for the frustum planes.

FrustumPlane[0].Set(0, 0, 1, nearz); // near.

FrustumPlane[1].Set(0, 0, -1, -farz); // far.

FrustumPlane[2].Set(-cos(ViewAngleH/2), 0, sin(ViewAngleH/2), 0); // left.

FrustumPlane[3].Set(cos(ViewAngleH/2), 0, sin(ViewAngleH/2), 0); // right.

FrustumPlane[4].Set(0, -cos(ViewAngleV/2), sin(ViewAngleV/2), 0); // top.

FrustumPlane[5].Set(0, cos(ViewAngleV/2), sin(ViewAngleV/2), 0); // bottom.


void Display()
// Display function.

// Turn on z-buffering.


// Set up the view matrix.

matrix ViewMatrix;
ViewMatrix.View(ViewerDir, ViewerUp, ViewerLoc);

// Transform the frustum planes from view coords into world coords.

int i;
for (i = 0; i < 6; i++) {
// Rotate the plane from view coords into world coords. I''m pretty sure this is not a slick

// way to do this <img src="smile.gif" width=15 height=15 align=middle>

PlaneInfo& tp = TransformedFrustumPlane[i];
PlaneInfo& p = FrustumPlane[i];
ViewMatrix.ApplyInverseRotation(&tp.Normal, p.Normal);
vector v;
ViewMatrix.ApplyInverse(&v, p.Normal * p.D);
tp.D = v * tp.Normal;

// Clear buffers.

glClearColor(0, 0, 0, 0);

// Draw the quadtree.

if (root) {
root->Update(RootCornerData, (const float*) ViewerLoc, Detail);
TriangleCounter += root->Render(RootCornerData, Textured);

// Show frame.


From what I can tell, it looks like your 6 basic frustrum planes are setup
in local space at the origin. Then when it is time to use them at some
point in world space, all six planes are transformed. I haven''t studied
the code much yet, so I am unfamilar exactly how the planes are transformed.
But it looks like they do something with the planes'' normals and D equation

Share this post

Link to post
Share on other sites

  • Advertisement

Important Information

By using GameDev.net, you agree to our community Guidelines, Terms of Use, and Privacy Policy.

We are the game development community.

Whether you are an indie, hobbyist, AAA developer, or just trying to learn, GameDev.net is the place for you to learn, share, and connect with the games industry. Learn more About Us or sign up!

Sign me up!