gluPerspective, glViewport, gluLookAt and the GL_PROJECTION and GL_MODELVIEW Matricies

问题

Original Question

I want to use 'gluPerspective', 'glViewport' and 'gluLookAt' to manipulate my camera and screen.

Which functions to I apply to which matrix mode? And in what order should I / must I use them?

For example, I am trying to set up my screen and camera like this: (But it is not working!)

glMatrixMode(GL_PROJECTION) // Apply following to projection matrix - is this correct?
glLoadIdentity(); // Reset first
glPerspective(45.0, (double)w/(double)h, 1.0, 200.0); // Set perspective
glViewport(0, 0, w, h); // Set viewport

glMatrixMode(GL_MODELVIEW); // Apply following to modelview - should glViewport come under here?
glLoadIdentity(); // Reset first
gluLookAt(px, py, pz, cx, cy, cz, ux, uy, uz); // Set position, centre and then up vectors
// This surely comes after calling GL_MODELVIEW?

I have looked around for online documentation, and I understand the functions, just not where they should go and in what order!

Some time later...

It is several months later now and I am adding a quick edit to show the system I use to render things with OpenGL. This is to help others who see this question in the future.

I primarily use two methods.

Method 1:

This method groups everything together.

// Firstly, the window may have been resized so re-create the viewing area
glViewport(0, 0, width_of_window_rendering_area, height_of_window_rendering area);

This recreates the viewport for rendering over the entire area of the inside of the window. With sfml, you would do something like window.width() or window.height(), or something similar depending on which windowing toolkit you use (glut, glfw, sdl etc)...

// The second step is to add a projection matrix. There are three main ones I like to use
// Uncomment the one you want
glMatrixMode(GL_PROJECTION); // Tell OpenGL to manipulate the correct matrix stack
glLoadIdentity(); // Reset the projection matrix, or bad things happen after multiple calls to below functions!
// glOrtho( ... ) // Uncomment to use 2D rendering
// gluPerspective( ... ) // Uncomment to use (easy) 3D rendering
glFrustrum( ... ) // Uncomment to use (harder/less intuitive?) 3D rendering
glMatrixMode(GL_MODELVIEW); // I always prefer to leave OpenGL in the modelview manipulation mode.
    // I consider it the "default" and safest mode to leave OpenGL in, as any rogue
    // calls to functions changing its contents is likely to mess up your geometry
    // which should be visible as a problem on the screen, which tells you you need
    // to fix something! Manipulating the other matrix stacks may not show obvious
    // problems.

You will need to select one of the three out of 'glOrtho', 'gluPerspective' and 'glFrustrum'. There is also 'gluOrtho2D', but use that with care! (I prefer to specify near and far planes myself with 'glOrtho'.) You need to replace the '...' with your arguments to the function also.

// The third step is to clear the screen and set your camera / geometry position
glClear(GL_COLOR_BUFFER_BIT); // use bitwise OR ('||') with 'GL_DEPTH_BUFFER_BIT' and 'GL_STENCIL_BUFFER_BIT' if required
gluLookAt( ... );
// I like to use gluLookAt, or at least I _italic_used to! Now I implement my own camera...
 // That is another fun thing you should try if you are comfortable with 3D geometry and hard math!

// The fourth step is to draw your scene. You may want to put lighting stuff first or in with the drawing
glutWireTeapot( ... );

Method 2:

The second method is the same as above, but to move the first step into a separate function. Then you must detect window resize events and call this function. With glut, you can specify a callback. With SFML you can detect an event when the window is resized. I forget how SDL works, but it is similar. I have not yet learned how glfw works.

Hopefully that will help you.

Some OpenGL novices (probably myself included at one time) try to specify camera translations on the PROJECTION matrix. Do not do this - I head it messes up lighting and possibly other things.

回答1:

I define my reshape callback function as:

Call glViewport(...) once in the beginning.

Then reload the projection matrix with an identity matrix:

glMatrixMode(GL_PROJECTION);
glLoadIdentity();

Then:

glPerspective(...)
glMatrixMode(GL_MODELVIEW);

gluLookAt(...) can be called anytime later if you need to change your camera position.

Works for my simple purposes.

来源：https://stackoverflow.com/questions/13053334/gluperspective-glviewport-glulookat-and-the-gl-projection-and-gl-modelview-mat