Lighting – Light Sources Lecture 12 Wed, Sep 19, 2007

Lighting and Reflection The shade of a pixel is determined by two things: The light source(s). The material properties. The light sources determine the color and intensity of the light striking the surface. The material properties determine how that light is reflected.

Types of Light Source Ambient Point Source Directional Source Light source has no position in space. Point Source Light source is at a point in space. Light strikes different objects from different directions. Directional Source Light source is “at infinity.” Light strikes all objects from same direction.

Types of Light Source Emissive The object itself emits light. This is really a material property, not a light source. It does not illuminate other objects.

The Lighting Model To use lighting, the lighting model must be enabled: glEnable(GL_LIGHTING); When lighting is enabled, shading is determined by the lighting and material properties only; the glColor() function has no effect*. *Unless you enable GL_COLOR_MATERIAL.

General Ambient Light The only default lighting is the general ambient light, set to (0.2, 0.2, 0.2). This is independent of all regular light sources. The function glLightModel*() can be used to change the general ambient light. float model_ambient[] = {0.5, 0.5, 0.5, 1.0}; glLightModelfv(GL_LIGHT_MODEL_AMBIENT, model_ambient);

Examples In the following examples, the material properties have been set to reflect all incident light.

Default Lighting Model Read Run

Light Source LIGHT0 OpenGL supports up to 8 separate light sources, each with its own characteristics. The are named LIGHT0, …, LIGHT7. The defaults for LIGHT0 are different from the defaults for LIGHT1 through LIGHT7. Otherwise, the 8 light sources are handled in the same way.

Defaults for Light Sources Ambient (0.0, 0.0, 0.0) Diffuse (1.0, 1.0, 1.0) Specular (1.0, 1.0, 1.0) Position (0.0, 0.0, 1.0) Defaults for LIGHT1 through LIGHT7 All types of light (0.0, 0.0, 0.0)

Enabling Lights Each light must be enabled. To enable LIGHT0, make the function call glEnable(GL_LIGHT0);

Default Settings for LIGHT0 Read Run

Point and Directional Sources At each point of a surface, the light has a direction. Point source – direction varies with position on surface. Directional source – direction does not vary with position on surface. Furthermore, with a point source, the intensity may vary with the distance from the source if we enable light attenuation.

Positioning the Lights Each light can be positioned at any point. OpenGL code to position LIGHT0: float light_position[] = {10.0, 10.0, 10.0, 1.0}; glLightfv(GL_LIGHT0, GL_POSITION, light_position);

Positioning Lights at Infinity A light source may be placed “at infinity” by setting the fourth coordinate to 0.0. float light_position[] = {1.0, 1.0, 1.0, 0.0}; The default type is directional. This example gives the light the direction vector (1, 1, 1), but no position in space. In other words, for objects in all locations, the light will shine from the direction (1, 1, 1).

LIGHT0 Positioned at (10, 10, 10) Read Run

Positioning the Light Sources The light sources may be set relative to the world coordinates (fixed) or relative to the camera (moveable). If they are relative to world coordinates, then the lighting remains the same when the camera is moved. If they are relative to the camera, then the lights move with the camera.

Positioning the Light Sources To make the light source fixed, the light’s position should be set after the camera is set. When the camera moves the scene, the lights move with the scene. To make the light source move with the camera, the light’s position should be set before the camera is set. The lights will not move with the scene.

Positioning the Light Sources We can make the lights fixed or moveable by swapping the order in which the functions setView() and setLights() are called. // Fixed lights setView(); setLights(); // Moveable lights setLights(); setView();

Positioning the Light Sources We can make the lights fixed or moveable by swapping the order in which the functions setView() and setLights() are called. // Fixed lights setView(); setLights(); Lights are transformed with the scene // Moveable lights setLights(); setView();

Positioning the Light Sources We can make the lights fixed or moveable by swapping the order in which the functions setView() and setLights() are called. // Fixed lights setView(); setLights(); // Moveable lights setLights(); setView(); Lights are not transformed with the scene

Fixed vs. Moveable Lights Read Run

Ambient Light Ambient light illuminates objects equally in all directions. In real life, ambient light is light that has been reflected off so many surfaces that it is impossible to identify the source.

Ambient Reflection The ambient reflection depends on The ambient light inherent in the scene. The ambient light given off by the light sources. The ambient property of the surface.

Setting the Light Properties The function glLight*() is used to set the various light properties, such as ambient light. It takes three parameters The light source. The light property. The value.

Setting the Ambient Light OpenGL code to set the ambient light for LIGHT0: float light_ambient[] = {0.3, 0.3, 0.3, 1.0}; glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);

LIGHT0 Ambient Light (0.3, 0.3, 0.3) Read Run

Diffuse Reflection Intensity of reflected diffuse light Depends on angle of incidence. Reflects equally in all directions, i.e., does not depend on the viewing angle. It can be computed more efficiently if the light is directional, since there is one less variable.

Setting the Diffuse Light OpenGL code to set the diffuse light for LIGHT0: float light_diffuse[] = {0.5, 0.5, 0.5, 1.0}; glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);

LIGHT0 Diffuse Light (0.5, 0.5, 0.5) Read Run

Specular Reflection Intensity of reflected specular light varies with viewing direction. Maximum intensity is in the direction pointing directly along the angle of reflection.

Specular Reflection Specular reflection creates the appearance of “shininess.” Surfaces with a high specular reflection appear very shiny. Surfaces with a low specular reflection appear matte.

Specular Reflection Computing specular reflection is less efficient than computing diffuse reflection, since it depends on the direction to the viewer as well as the position of the light source. The calculations can be speeded up if the viewer is placed “at infinity.”

Setting the Specular Light OpenGL code to set the specular light for LIGHT0: float light_specular[] = {1.0, 1.0, 1.0, 1.0}; glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);