Terrain Tutorial

Simulating Lighting Computations

Lighting a surface can be a costly operation. In this section it will be shown how to compute the colors of a vertex as if it was being lit by a light source. For the sake of simplicity only the diffuse component will be taken into account. Two types of light sources will be considered: Directional and Point lights.

According to the red book the diffuse component of the vertex color is defined as

    
	(max { L . n, 0} ) * diffuseLight * diffuseMaterial
	
	where 
		L is a unit length vector that points 
			from the vertex to the light position
		n is a unit lenght normal for the vertex
	and
		L . n    means the inner product between two vectors

The definition of inner product is as follows:

    
Consider two vectors a = [ax,ay,az] and b = [bx,by,bz].

the inner product is a number computed as following:

	ip = ax * bx + ay * by + az * bz

As mentioned before two types of lights are dealt in here: Directional and Point lights. For a directional light the vector L is constant because the light rays are considered to be parallel, i.e. the vector from a vertex to the light position is not dependent of the vertex position. In fact, in OpenGL when defining a Directional Light we're not defining its position but the direction L. Because OpenGL does not require this vector to be unit length it is necessary first to normalize it. To compute the diffuse component the following information is required:

L = [Lx,Ly,Lz] - the vector from the vertex to the light source

n = [nx,ny,nz] - the vertex normal

dL = [dLR, dLG, dLB] - the diffuse component of the light (RGB)

dv = [dvR, dvG, dvB] - the diffuse component of the vertex (RGB)

The complete process for lighting a vertex with a directional light is resumed to:

    
	1. Normalise L
	
		l = sqrt(Lx * Lx + Ly * Ly + Lz * Lz);
		Lx = Lx / l;
		Ly = Ly / l;
		Lz = Lz / l;
		
	2. Compute the inner product between L and n.
	
		ip = Lx * nx + Ly * ny + Lz * nz
		
	3. Check to see if its larger than zero
	
		if (ip < 0)
			ip = 0;
	
	4. Compute the vertex lit color vc = [vcR, vcG, vcB]
	
		vcR = ip * dLR * dvR
		vcG = ip * dLG * dvG
		vcB = ip * dLB * dvB

In the directional light case, step 1, the normalisation of L, should be done only once because L is the same for every vertex.

For point lights, the process is similar, the only difference being in step 1. In this case the computation of L is required. Assuming that

the vertex position is v = [vx,vy,vz],

the light position is l = [lx,ly,lz]

then step 1 becomes:

    
	1.1. Compute the vector from the vertex to the light source
	
		vl = [vlx, vly, vlz]
		
		where
			vlx = lx - px
			vly = ly - py
			vlz = lz - pz
			
	1.2. Normalise vl to obtain L
	
		length = sqrt(vlx*vlx + vly*vly + vlz*vlz)
		
		Lx = lx / length
		Ly = ly / length
		Lz = lz / length

Steps 2 to 4 are identical for both light types. The next section shows the implementation details and the relevant functions.

[Previous: Computing Normals] [Next: Implementation Details]