OpenGL: why do I have to set a normal with glNormal?

Question

I'm learning some basics of OpenGL but I'm wondering why there is a call glNormal to set the normal of vertices.

If I create a simple triangle like this:

glBegin(GL_TRIANGLES);
    glVertex3f(0,0,0);
    glVertex3f(1,0,0);
    glVertex3f(0,1,0);
glEnd();

Shouldn't the normals be defined implicitly by the type of the geometric primitive? If I don't set a normal will OpenGL calculate it?

Answer 1

Calling glNormal multiple times between glBegin/End allows you to set a normal per vertex instead of per primitive.

glBegin(GL_TRIANGLES);
    glNormal3f(0,0,1);
    glVertex3f(0,0,0);
    glNormal3f(0,0,1);
    glVertex3f(1,0,0);
    glNormal3f(0,0,1);
    glVertex3f(0,1,0);
glEnd();

For a more complex mesh consisting of multiple triangles you would want the normal at one vertex depend on the other triangles of the surrounding geometry and not just the normal of the triangle it belongs to.

Here is an example of the same geometry with:

• on the left per-vertex normals - so each vertex of a face has a different normal (for this sphere it means all normals point outward from its center), and
• on the right per-face normals - each vertex gets the same normal value (since you specify it only once, or because it uses the default normal value of (0,0,1)):

The default shade model (GL_SMOOTH) causes the normals of the face's vertices to be interpolated across the face. For the per-vertex normals this results in a smooth shaded sphere, but for the per-face normals you end up with the characteristic faceted look.

Answer 2

The short answer is that you don't actually have to set a normal at all. Normal vectors are only used if you're performing OpenGL lighting (or perhaps some other calculation that may depend on them), but if that doesn't apply to you (or if you're using some other method to do lighting, e.g. lightmaps) then you can quite happily omit all glNormal calls.

So let's assume that you are doing something where specifying glNormal makes sense and look at it some more.

glNormal can be specified per-primitive or per-vertex. With per-primitive normals all that it means is that all of the normals for each vertex in the primitive face in the same direction. Sometimes this is what you want but sometimes it isn't - where per-vertex normals come in useful is that they allow each vertex to have it's own facing.

Take the classic example of a sphere. If each triangle in a sphere had the same normal then the end result would be quite faceted. That's probably not what you want, you want a smooth shading instead. So what you do is average the normals for each triangle that shares a common vertex, and get a smooth shaded result.

Answer 3

No, GL does not calculate a norm for you. It cant't know what the normal should be. Your primitives don't mean anything outside of rasterization (and a few other places). GL doesn't know which faces (triangles) share a vertex (calculating this at runtime is very expensive without using different data structures).

You need to preprocess a mesh's "triangle soup" to find common vertices and calculate normals. This should be done before the game runs for speed.

There are also cases like hard edges where geometrically there is a shared vertex at the corner, but you want separate normals so it lights correctly. In the GL/D3D rendering model, you need two separate vertices (at the same position) for this, each with a separate normal.

You'll need all this for UVs and texture mapping, too.

Answer 4

You need the glNormal to implement some features coder-dependant. For instance you might wish to create normals dat preserve hard edges.