What is DOT3 lighting?

Question

An answer to my question suggests that DOT3 lighting can help with OpenGL ES rendering, but I'm having trouble finding a decent definition of what DOT3 lighting is.

Edit 1

iPhone related information is greatly appreciated.

Answer 1

From here:

Bumpmapping is putting a texture on a model where each texel's brightness defines the height of that texel.

The height of each texel is then used to perturb the lighting across the surface.

Normal mapping is putting a texture on a model where each texel's color is really three values that define the direction that location on the surface points.

A color of (255, 0, 0) for example, might mean that the surface at that location points down the positive X axis.

In other words, each texel is a normal.

The Dot3 name comes from what you actually do with these normals.

Let's say you have a vector which points in the direction your light source points. And let's say you have the vector which is the normal at a specific texel on your model that tells you which direction that texel points.

If you do a simple math equation called a "dot product" on these two normal vectors, like so:

Dot = N1x*N2x + N1y*N2y + N1z*N2z

Then the resulting value is a number which tells you how much those two vectors point in the same direction.

If the value is -1, then they point in opposite directions, which actually means that the texel is pointing at the light source, and the light source is pointing at the texel, so the texel should be lit.

If the value is 1, then they point in the same direction, which means the texel is pointing away from the light source.

And if the value is 0, then one of the vectors points at 90 degrees relative to the other. Ie: If you are standing on the ground looking forward, then your view vector is 90 degrees relative to the normal of the ground which points up.

Answer 2

DOT3-lighting is often referred to as per-pixel lighting. With vertex lighting the lighting is calculated at every vertex and the resulting lighting is interpolated over the triangle. In per-pixel lighting, as the name implies, the object is to calculate the lighting at every pixel.

The way this is done on fixed function hardware as the iPhone is with so called register combiners. The name DOT3 comes from this render state:

glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_DOT3_RGB);

Look at this blog entry on Wolfgang Engels blog for more info on exactly how to set this up.

When doing per-pixel lighting it's popular to also utilize a so called normal map. This means that the normal of every point on an object is stored in a special texture map, a normal map. This was popularized in the game DOOM 3 by ID software where pretty low polygon models where used but with high resolution normal maps. The reason for using this technique is that the eye is more sensitive to variation in lighting than variation in shape.

I saw in your other question that the reason this came up was that you wanted to reduce the memory footprint of the vertex data. This is true, instead of storing three components for a normal in every vertex, you only need to store two components for the texture coordinates to the normal map. Enabling per-pixel lighting will come with a performance cost though so I'm not sure if this will be a net win, as usual the advice is to try and see.

Finally the diffuse lighting intensity in a point is proportional to the cosine of the angle between the surface normal and the direction of the light. For two vector the dot product is defined as:

a dot b = |a||b| cos(theta)

where |a| and |b| is the length of the vectors a and b respectively and theta is the angle between them. If the length is equal to one, |a| and |b| are referred to as unit vectors and the formula simplifies to:

a dot b = cos(theta)

this means that the diffuse lighting intensity is given by the dot product between the surface normal and the direction of the light. This means that all diffuse lighting is a form of DOT3-lighting, even if the name has come to refer to the per-pixel kind.