I've been reading this opengl guide: http://fly.cc.fer.hr.../chapter03.html
I didn't quite understand the whole idea behind matrices.

Like in the next given reshape function that I'm supposed to assign to my windows library:

void reshape(GLsizei w, GLsizei h)
{
glMatrixMode (GL_PROJECTION); /* prepare for and then */
glLoadIdentity (); /* define the projection */
glFrustum (-1.0, 1.0, -1.0, 1.0, /* transformation */
1.5, 20.0);
glMatrixMode (GL_MODELVIEW); /* back to modelview matrix */
glViewport (0, 0, w, h); /* define the viewport */
}


I didn't really get the idea behind changing to matrix modes and what each matrix does.
I also didn't understand what's the difference between glFrustum and glOrtho and when I should use each function.
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?

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

Some explanations may help, thanks!

The matrices convert points in world coordinates to points in screen coordinates.

The projection matrix takes vertices in 3d geometry and projects them onto your 2d screen. Every frame each vertex is multiplied by the projection matrix to determine its 2d coordinates on screen.

Before this however, the model view matrix is used to convert vertices from object coordinates into world coordinates relative to your view. So if you are rendering a cube for example and you define the center of the cube to be point 0,0,0 in object coordinates, and one of the corners is 1,1,-1, and then it is positioned 12 units in front of your camera, and 5 units up, the model view matrix determines the coordinate of the vertex relative to your camera position, ie what the vertex would be if your camera was 0,0,0.

You can work with the model matrix and view matrix separately, which I prefer, but some versions of OpenGL (like OpenGL ES 1.0) don't allow this. In the end you'll pass only the combined MVP matrix to your shader.

The glPerspective and glFrustrum methods are used to determine the view matrix for you. Use glPerspective if you want to specify a horizontal and vertical FOV.

The "planes" you're talking about are near and far clipping planes, they just determine how far and close you should be able to see objects. So if you specify a far clipping plane of 100, you won't be able to see any objects more than 100 units from the camera (ever wonder why old games use fog?) The farther you set the far clipping plane, the farther away you'll be able to render objects, but if you set it too far out OpenGL will have a harder time determining which objects should be in front of eachother.

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

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)).

Maybe you should read the books about 3D Graphics first, then you will understand how [font="arial"][size="2"][color="#000000"]it works..[/font]