Is the far clipping plane the value I pass to zFar in glFrostum?

A viewing frustum has six clipping planes (

http://en.wikipedia....Viewing_frustum). OpenGL checks vertices passed to it to see which side of the plane they exist on. If they are within the frustum then they are observable on screen.

You're sort of the right lines with your statement. The value you pass to zFar forms the z-coordinate that is used when creating the frustum.

[source lang="cpp"]glMatrixMode(GL_MODELVIEW);glPushMatrix(); /* perform camera movement */ glPushMatrix(); /* list coordinates */ glPopMatrix();glPopMatrix();glMatrixMode(GL_PROJECTION); /* switch to the projection matrix */glLoadIdentity(); /* load an identity matrix so we don't add to the previous matrix */glFrustum(-aspect, aspect, -1.0, 1.0, aspect / tan(fov / 2.0f), 1000.0); /* create a frustum */glViewport(0, 0, WIDTH, HEIGHT);[/source]

Where 'aspect' is defined as your aspect ratio (WIDTH / HEIGHT) and 'fov' is the desired field of view.

I didn't quite understand the whole idea behind matrices.

A matrix is a method presenting transformations in a coordinate system. OpenGL multiples the vertices that are passed to it by the matrix so that their final position can be determined. For example if you had a rotation matrix R that stored the details to rotate a model by 45 degrees and we had a model (a model is just a series of vertices) then we can multiple all of the points in the model by R and rotate the model.

I didn't really get the idea behind changing to matrix modes and what each matrix does.

OpenGL is written as a giant finite state machine. It contains three matrices - the projection matrix, the modelview matrix, and the texture matrix (I won't talk about the last).

Vertices that are passed to OpenGL are actually multiple by both the modelview and projection matrices. This is odd because it isn't like you can modify the camera in the projection matrix and coordinates in the modelview matrix (this is what I thought when I started).

OpenGL first multiples vertices by the modelview matrix to determine the 'eye'-coordinates. The eye coordinates are the position of the points in the world relative to the camera.

The projection matrix is used for clipping.

I also didn't understand what's the difference between glFrustum and glOrtho and when I should use each function.

They are different methods of projection. Frustum creates the illusion of depth because of the way objects are mapped to the final viewport and Ortho is short for orthographic.

And, I understood that gluPerspective is used as an alternative function to glFrustum, with both functions using different parameters, so when should I use each one?

The answer is that it doesn't really matter. I'm slightly hardcore (or stupid; probably) and I try and use only OpenGL's commands and avoid GLUT and the utility library (glu*). Both glFrustum and gluPerspective dump the same matrix on the projection matrix stack they just allow it to be specified with different ways.

Also, I don't know what's that "plane" that the author is talking about all the time. (probably because of my poor English)

A plane is a mathematical object that has only two dimensions (

http://en.wikipedia....lane_(geometry)).

**Edited by BinaryPhysics, 07 July 2012 - 07:00 AM.**