   Separating the world and view matrices...
  I'm not an expert by any means, but I'm a bit more familiar with DirectX than OpenGL, and I'm finding the lack of separation between world and view matrices (the latter being the inverse of the camera's world matrix) to be one of the most difficult things to cope with. I mean, I understand that, in principle, the separation is somewhat arbitrary. Did the camera more or did the object move? Relativistically-speaking, it doesn't matter.But it's sure useful to have them separate sometimes. Take Blinn-Phong shading as an example. In order to calculate the Half vector, I need the Eye vector as the Light vector.Calculating the Eye vector is simple. Simply transform the vector by gl_ModelViewMatrix and then negate the result, then normalize. Voila.Calculating the Light vector seems a little more complicated. Consider a directional light. I can send the light direction down into the vertex shader through a uniform. However, this direction is likely to be in world space. I can't create a Half vector using an Eye vector that is in eye space and a light vector that is in world space. They have to both be in the same coordinate system, right?So, how can I transform the light vector into eye space? I can't use gl_ModelViewMatrix because that matrix applies to the object I'm rendering, not the light. Unless the object I'm rendering is unrotated, this isn't going to work. For this, I need the view matrix to be separated from any other world matrix concatenations that may have taken place.I could, alternately, pass the 'view matrix' (which is created by gluLookAt or what have you) down as a uniform. However, in doing so, it seems I'm sort of violating this ModelView unity concept, which is fine by me as long as this is the way it is typically done.I think there is something with this that just isn't clicking with me. I can see that the OpenGL way of doing things has worked for zillions of highly intelligent people for years and years, even before programmable shaders when programmers didn't have full control over the inputs of the shading process.Can someone help me snap into the OpenGL mentality? How would one handle the above half-vector calculation, for example?   
  It's simple: Handle the matrices yourself, in the way you require them to be handled. The MODELVIEW matrix is for the purposes of OpenGL, less for your own purposes (so to say). With the preference for shader scripts, the matrix stack is consequently made deprecated with OpenGL 3 anyway.   ;  well youre using glsl thusdont use the unbuilt uniform mat4 gl_ModelViewMatrixbut create 2 yourselfuniform mat4 ModelMatrix;uniform mat4 ViewMatrix;void Main(){gl_vertex = ModelMatrix * ViewMatrix * gl_Vertex;}or whatever;  Hi,In GLSL, the half vector is automatically provided under light.halfVector, but to your first question, my solution is to do the world space transforms on a separate matrix.  Pseudo://SETUPclearset viewset camera w/ gluLookAt//TO DRAW AN OBJECTuse shader "my_shader"transform objectglPushMatrix()glLoadIdentity()transform objectget contents of the matrix and pass to "my_shader"glPopMatrix()draw object-G   ;  One thing to note is that light vectors in OpenGL (unless passing them in manually as uniforms) are stored in eye space already afaik, thus there is no need to be working in world space.From OpenGL 3.2 the API no longer handles any matrix operation anyway, so as the other repliers mentioned, handling them yourself is the best call.   