Cameras are not the right way to think about OpenGL
Sigh, the tales of an old programmer. I'm teaching myself 3d graphics. My bag of 2d tricks has been used up, 3d has been around for almost 10 years in the mainstream, and it's time to move on.
To learn, I set out to make a little 3d representation of the mandelbrot set. I thought I could just whip that baby out in no time. But, as it turned out, I can't. I had to overcome some basic hurdles with Opengl.
A few things went through my head.
A lot of OpenGL tutorials talk about cameras, and yet, OpenGL doesn't have cameras. Instead, you get a bevy of matrixes and glMatrixModes. Computer science is full of horrific analogies, and I really think that "camera" metaphor people use to describe OpenGL is one of them. I ask myself, in my best Battlestar Galactica parlance, "what the frak going on!!!!"
As I was smashing my keyboard with my fist, causing my shepherd to hide under the bed, two things dawned on me. First is, thank God Logitech keyboards are indestructible. Second, all these matrixes do is move pixels around. There's nothing magic going on. The camera is a lie.
OpenGL is about a set of vertices, or points, in a 3d space. You draw them into 3d coordinates using any of various primitives, such as TRIANGLE_FAN, TRIANGLE_LIST, etc. OpenGL marches through each of these points and "transforms" them into a set of coordinates that look three-dish on screen.
Thus, when you specify various transformations, you are telling OpenGL how to move your points around. With that perspective, you can understand GL_PROJECTION and GL_MODELVIEW this way:
GL_PROJECTION is a matrix transformation that is applied to every point that comes after it, always. GL_MODELVIEW is a matrix transformation that is applied to every point in a particular model. There's a hierarchy of transformations, with GL_PROJECTION at the top, and a set of GL_MODEL branches. You set the matrix transformation with glMatrixMode. By default, the matrix mode is GL_MODELVIEW, which assumes everything you draw will be in one 3d space.
Let's talk about GL_PROJECTION first.
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-1, 1, -1, 1, -1.0, 1.0);
It's all about matrix math. I basically use the glOrtho to apply some perspective to what I'm doing. Everything in 3d graphics is about matrix math.
Once you set the matrix mode, each subsequent operation is applied to that particular matrix mode and below it. They almost should have called it matrix levels and not matrix modes. I load identity first to give it a place to start because most of the gl matrix commands work by multiplying themselves against whatever the matrix was for that mode before. For example:
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-1, 1, -1, 1, -1.0, 1.0);
glTranslate( 100, 100, 100 );
glRotateF( 45, 1, 0, 0 );
Really means: GL_PROJECTION_MATRIX = IDENTITY * ORTHOGRAPHIC_MATRIX * TRANSLATION_MATRIX * ROTATION_MATRIX.
The order of these calls seems extremely important.
So what's MODEL_VIEW all about? GL_PROJECTION transformations are always applied, so, we can use it to define a camera, set the perspective, among other things. What model view lets us to do is set up different measuring systems for vertices of different things. I select model view by calling
glMatrixMode(GL_MODELVIEW);
Then I can apply stuff to the model:
glLoadIdentity();
glTranslate( modelx, modely, modelz );
To move it in space somewhere, for example.
GL_MODELVIEW is about having different objects being pushed into a "world space". The biggest reason is that I can draw each object using coordinates based around 0, merely specifying the translations or rotations or scaling based on how I want my model to go.
To really appreciate this, let's consider a simple example. I want to draw a world that has two things in it, a car and a battleship. To do this, I might:
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-1, 1, -1, 1, -1.0, 1.0);
glTranslate( camerax, cameray, cameraz );
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslate( carx, cary, carz );
// draw car here, by specifying various gl vertices
glLoadIdentity();
glTranslate( battleshipx, battleshipy, battleshipz );
// draw battleship here, by specifying various gl vertices
In that example, each car vertice I specify is being altered as follows:
car_vertice_matrix = projection_ortho_matrix * projection_translation * car_translation_matrix
and, for the battleship
battleship_vertice_matrix = projection_ortho_matrix * projection_translation * battleship_translation_matrix
So, to actually draw the stuff, OpenGl takes the projection matrix multiplied by the current model matrix and uses that to translate each specific vertice within that model. Wow, 3d graphics is not hard. Hell I should go write my own OpenGL. You know, if there wasn't the issue of hardware accelaration, it would be tempting. Well, I still got a ways to go.
I'll have my little multithreaded 3d demo up shortly. There's actually a bug in my thread pool that I will be posting a fix for as well.
I remember reading somewhere in a 3d graphics book that the glProjection matrix should not be used to fake a camera. I think that was an evil thing to remember. But, wow, it just seems like it would be such a good spot to do it. What I have to try is something like this:
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-1, 1, -1, 1, -1.0, 1.0);
glTranslate( camerax, cameray, cameraz );
glRotateF( cameraanglex, 1, 0, 0 );
In that case, the glTranslate would be where the camera is, and glRotateF, where it is facing.
Talking about cameras
Now, I know I said that the camera is a lie. It is, because its pretty obvious that we're really moving the entire world to get our picture, and not some "camera".