Light Sources

Light from source such as light bulb treated by considering each point on surface.
Point (x,y,z)
Direction of emission (theta, phi)
Wavelength lambda

To get contribution from surface, integrate over surface - difficult in practice.
 

Color

Treat each color independently. That is I = [ Ir, Ig, Ib]^T

Ambient Light

Considered uniform at each point in scence
 

Point Sources

Emits light equally in all directions.  The light intensity decreases with the square of the distance from the
source.
I(p, p0) = I(p0)/|p - p0|^2
where p0 is the source and p a point on a surface.

Problem with point sources. Object are either illuminated or not - very sharp contrast.
In real life non-point sources give gradual shadows (umbra and penumbra)

In OpenGL can soften contrast by using ambient light.  Can also do by using some other decay term than quadratic.
In OpenGL can use  (a + bd + c d^2)^-1  where d is distance.

If source is sufficiently remote can assume light uniform over a surface.

Spotlights

Point source - angle of light limited to theta - about direction Is. Theta - 180 is point source.

More realistic if light intensity falls off as w emove away from center rather than just cut off at theta.
Modelled by intensity proportional to
Cos^e phi
where phi is angle away from Is.

 
 
 

Distant  Light Sources

In the case of sources sufficiently far from surface we can assume that light incident on each point
in the surface comes from the same direction. This avoids having to calculate direction to source
seperately for each point.

In practice replace location of light with direction of light. In homogeneous coordinates this means replace
p0 = [x y z 1]^T with p0 = [x y z 0]^T.
 

Illumination Models

local illumination
defines single-light, single-surface interaction
global illumination
models interchange of lights between all surfaces

Local Illumination Models

Traditional graphics LIMs are:

Most such adhoc illumination models have three components: 
 I = ambient + diffuse + specular

Ambient Light

The ambient term allows for some global control of brightness in a scene. Typically, 
 I = Ia ka
where Ia is an ambient illumination constant defined once for the entire scene, and ka is an ambient reflection coefficient, usually restricted to lie in [0,1].




Diffuse Reflection


  
Id = Ii k_diff cos(th), th in [-pi/2, pi/2]
    = Ii k_diff (N.L),   N.L  0 and assuming N and L are normalized
Ii: intensity of light source i
k_diff: surface reflection coefficient
th: angle between N and L
 
 
 

Phong Specular Reflection

The last component of the commonly-used local illumination model is one that takes into account specular reflections.
These are reflection from shiny surfaces which give rise to highlights.Note that these are often a different color to the
reflected ambient and diffuse light.
For example a red ball viewed under white light is red because it reflects the red component of the the ambient and diffuse
white light. However the specular reflection will cause a white highlight in the direction of the viewer.

The following figure illustrates the situation:

The Phong illumination model is one often-used method of calculating the specular component: 

  Is = Ii k_spec cos^n(alpha)
     = Ii K_spec (R.V)^n
where k_spec is a specular reflection coefficient and alpha is the angle between the reflection and viewing vector. The surface parameter 'n' can be thought of as describing the surface roughness, where an ideal mirror would have n of infinity, and a rough surface might have n=1.
In OpenGL n is called the 'shininess'. Values of 100 to 500 correspond to metallic surfaces showing narrow highlights, values < 100 to materials showing broader highlights.

How can R be computed?

The function cos^n(alpha) looks as follows:

The Complete Model

Combining the various models and assuming the Phong illumination model gives: 
I = Ia ka + Ii k_diff (N.L) + Ii k_spec (R.V)^n
where each of ka, k_diff, and k_spec are parameters which are associated with specific surfaces and take on values between 0 and 1. To deal with colour, three equations of the above form are typically used: 
I_r = Ia_r ka_r + Ii_r k_diff_r (N.L) + Ii_r k_spec_r (R.V)^n
I_g = Ia_g ka_g + Ii_g k_diff_g (N.L) + Ii_g k_spec_g (R.V)^n
I_b = Ia_b ka_b + Ii_b k_diff_b (N.L) + Ii_b k_spec_b (R.V)^n
Some other problems and their adhoc solutions:
What should be done if I>1?
Clamp the value of I to one.
What should be done if N.L < 0?
Clamp the value of I to zero or flip the normal.
How can we handle multiple light sources?
Sum the intensity of the individual contributions.





Distance effects

This is a more controversial issue. It is often considered that the light from point sources attenuates as the square of the distance from the source. Since point sources give unreasonably sharp shadows often add linear and constant terms as well.
In OpenGL can use  (a + bd + c d^2)^-1  where d is distance.

I = Ia ka + [ Ii k_diff (N.L) + Ii k_spec (R.V)^n ]/ (a + bd + c d^2)
 
 

Lighting in OpenGL

These are the steps required to add lighting to your scene.

          Define normal vectors for each vertex of all the objects. These normals determine the orientation of the object relative to
          the light sources.

          Create, select, and position one or more light sources.

          Create and select a lighting model, which defines the level of global ambient light and the effective location of the
          viewpoint (for the purposes of lighting calculations).

          Define material properties for the objects in the scene.
 

Light Sources

The following are calls which set the parameters of a light (these are the defaults for GL_LIGHT0)
GLfloat light_ambient[] = { 0.0, 0.0, 0.0, 1.0 };
GLfloat light_diffuse[] = { 1.0, 1.0, 1.0, 1.0 };
GLfloat light_specular[] = { 1.0, 1.0, 1.0, 1.0 };
GLfloat light_position[] = { 0.0, 0.0, 1.0, 0.0 };

glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);
glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);
glLightfv(GL_LIGHT0, GL_POSITION, light_position);
 
where light_position is (x,y,z,1.0) for positional light at x,y,z and (x,y,z, 0.0) for a directional  light from direction x,y,z
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);

To specify attenuation use for example
glLightf(GL_LIGHT0, GL_CONSTANT_ATTENUATION, 2.0);
glLightf(GL_LIGHT0, GL_LINEAR_ATTENUATION, 1.0);
glLightf(GL_LIGHT0, GL_QUADRATIC_ATTENUATION, 0.5);
Note the default is constant attenuation.

For spotlights the added components are cutoff angle, direction, and possibly the exponent
glLightf(GL_LIGHT0, GL_SPOT_CUTOFF, 45.0);
GLfloat spot_direction[] = { -1.0, -1.0, 0.0 };
glLightfv(GL_LIGHT0, GL_SPOT_DIRECTION, spot_direction);
glLightfv(GL_LIGHT0, GL_SPOT_EXPONENT, 5)
The larger the spot exponent the more concentrated the light.
 

Lighting Model

The OpenGL notion of a lighting model has three components:

The global ambient light intensity
GLfloat lmodel_ambient[] = { 0.2, 0.2, 0.2, 1.0 };
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);

Whether the viewpoint position is local to the scene or whether it should be considered to be an infinite distance away
By default an infinite viewpoint is assumed. To specify a local viewpoint:
glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);

Whether lighting calculations should be performed differently for both the front and back faces of objects
glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);

Material Properties

The following calls define the surface properties to be used for all subsequently drawn objects.
  glMaterialfv( GL_FRONT, GL_AMBIENT, ambient_rgba );
  glMaterialfv( GL_FRONT, GL_DIFFUSE, diffuse_rgba );
  glMaterialfv( GL_FRONT, GL_SPECULAR, specular_rgba );
  glMaterialfv( GL_FRONT, GL_SHININESS, n );
  glMaterialfv(GL_FRONT, GL_EMISSION, emission_rgba);

-----------------------------------

More Complex Models

The Blinn Specular Model

Blinn reformulated the specular reflection model so that it agreed better with experimental results. It makes use of a halfway vector, H, as follows: 
Is = Ii k_spec cos^n(alpha)
     = Ii K_spec (N.H)^n
The advantages of this model include: Shading Algorithms
flat shading
Invoke illumination model (IM) once for the polygon, use this as a colour for the whole polygon
Gouraud shading
Compute IM at the vertices, interpolate these colours across the polygon
Phong shading
Interpolate normals during scan conversion, apply IM at every pixel. (note: renormalization problem)
Problems with shading algorithms


Physics-based Illumination Models

Shadows