CIS 41<br> Chapter 6 - Lighting and Shading

CIS 41
Computer Graphics
Chapter 6 - Lighting and Shading

Overview

Shading is what gives the objects their three-dimensional appearance
Without shading, the surfaces look flat
- An orthographic projection of a sphere appears as a circle
- An orthographic projection of a cube (from (1, 1, 1) appears as a hexagon
We wish to develop lighting models that can represent the gradations of light striking the object
For purposes of performance, we want local (as opposed to global) models
- Local takes into account only the surface of the object being lit and the light sources
- Global takes into account all other surfaces as well (reflection, indirect lighting)

Light and Matter

The process of lighting (the interaction between the object, other surrounding surfaces, and the light source(s) is recursive due to reflections
The effect can be expressed as an integral known as the rendering equation
- Applying this equation would produce complete shading information
  - Shadows, reflections, partial reflectivity
- However, in practical terms, the equation can't be solved quickly enough to be inserted into the pipeline.
For purposes of performance we employ a simpler model which is an approximation that still provides resonable results.
- Based on a model known as Phong lighting
- Will follow light rays from the light source(s)
- Will model the effect of such rays on refelctive surfaces in the scene

A Closer Look at the Process

Follow a light ray from its source
- Light the viewer sees directly from the source is a function of the source's color
- Light reflected from an object is some function of the light's color and the objects surface
To determine the color of a particular pixel:
- Given a view/projection plane positioned between the COP and the scene, we treat the projection plane as a grid of rectangles with a 1-1 mapping to pixels.
- The only light we need to consider are rays passing through the COP.
- We thus start at the COP and follow projectors through each pixel/rectangle.
- Assuming complete opacity, the color of the pixel will be the color of the first object we intersect. This process allows us to ignore he vast majority of rays leaving the light source which have no effect on the lighting of the scene

Appearance Due to Surface Properties

Opaque objects reflect and absorb ALL of the light
Translucent object allow some light to pass through and afect other objects as well
Smooth objects appear shiny; rough objects appear dull
Orientation affects shading as well

Categories of Interaction Between Light and Surfaces

Specular Surfaces: light is reflected/scattered in narrow range of angles close to angle of reflection
- Mirors: perfectly specular-- single angle of reflection
Diffuse Surfaces: light is reflected in ALL directions
- Perfectly diffuse-- scatter light equally in all directions (appear same to all viewers)
Translucent Surfaces: some light prenetrates surface and emerges from another location on obeject
- Process of refraction -- glass and water

The Bidirectional Reflection Distribution Function (BRDF) is a single function describing the reflection, absorbtion, and transmission of light at the surface of a material:

Given an input direction and an output direction , the equation specifies the amout of light from the input direction reflected to the output direction
Function of 5 variables:
- Frequency of light
- pair of input angles
- pair of output angles
For a perfectly diffuse surface, the function results in the same value for all output directions
For a perfectly reflectlive surface, the value for any output direction is 0 except for the angle of reflection
In general, however, and like the rendering equation, this function is highly complex and expensive to compute, so we look for approximation models that can be computed efficiently
We thus look at light source models and then reflection models and combine the two to achieve an approximation

Light Sources

self-emission and reflection
- Will talk about emission when we deal with OpenGL
Using a distributed source (such as a light bulb) requires integrating the effect of the light coming from all the points on the surface
Using point sources makes calculation of the contribution of a source much easier

Color Sources

Again, the human visual system-- based on three tristimulus values (cones with different frquency sensitivities) allows us to restict ourselves to a red/green/blue lighting model
We thus describe a light source as
```
L = (L_R, L_G, L_B)
				 
```

Ambient Light

Provides uniform light through the scene
Diffuses scatter light omnidirectionally
Difficult to model accurately -- requires integration of the many light sources
Instead we concentrate upon the effect of this uniform lighting on the scene
- We assign an ambient intensity, I_a, to each point in the scene
- This value is identical at each point
We will label the individual color components as L_ar, L_ag, L_ab
Individual surfaces-- based on their properties may reflect this unifrm lighting differently.
Ambient light derives from light sources (and thus disappears if we turn off the source)
- OpenGL, however, allows us to have a global ambient light termwhich is independent of any particular source
- This provides SOME light in the environment

Point Sources

Emits light equally in all directions
Intensity of light received at point p from point source p₀ is inversely proportional to square of distance, i.e.,
```
                 1
L(p, p₀) =   -------------- L(p₀)
                |p-p₀²|
			
```
We use them because they're easy to use (rather than because they're an accurate model)
- Result in hight contrast
- Softness results from larger, more distributed light sources
  - Having full and partial shadow produces a more reaslistic contrast
  - Adding amient light to point sources can get us closer to this effect
  - Modifying the distance formula to
```
(a + bd + cd²)^-1    d is the distance between p and p₀
										
```
    can also soften the high-contrast effect by selecting appropriate values for a, b and c.

Spotlights

Light is emitted through a narrow range of angles
Can be obtained from a point source with a limit on the angles from which the light can be seen
If θ is 180° then we have a point source again
A more realistic spotlight has non-uniform distribution of light within the cone
- Closer to the center -- more intense
- This intensity is thus a function of the cos φ -- the angle between the direction of the source and the vector to the point on the surface
```
cos^eφ
								 	
```
- ... and as we briefly mentioned before, the angle between two vectors, u and v can be easily calculated by:
```
cos &phi = u · v
								
```
- The exponent, e determines how quickly the intensity drops off with respect to size of φ

Distant Light Sources

If the light source is distant:
- The rays striking the surface become effectively parallel and thus,
- we can consider the light as striking all points of the surface at the same angle
  - Thus, locations of the light source are replaced with directions of light source
  - The resulting calculations are simpler, but the results are different

The Phong Lighting Model

Efficient and good approximation to reality
Phong/Phong-Blinn/modified Phong
Basis for lightinig in virtually all graphics systems and cards

The Four Vectors of Phong Lighting

Given arbitrary point p:

n - the normal -- the vector perpendicular to the surface at p
v - the direction from p to the COP (viewer)
l - the direction from p to the (point) light source
r - the direction the perfectly-refected ray from l would take upon bouncing off p

Some points about the above:

If the surface is curved, these vectors can change from point to point
r is completely deermined by n and l
a distributed light source complicates the calculation of l

Ambient, Diffuse and Specular Light-Surface Interactions in Phong

Phong supports all three
Each light source has RGB components for each of the above lighting types
- Not realistic, but we're not interested in modelling the physics realistically...
- We're interested in producing realistic effect
- Playing games to achieve with a local model global effects
We thus have nine components, which we place in a 3 x 3 illumination array-- we'll call it L_i
- Rows are the lighting types, cols are the RGB components
The surface the light is illuminating similary has nine components for reflection for each light source-- call it R_i
- Three for each color component for each of the three lighting types
For each color component (RGB), we can determine the lighting intensity (I_r, I_g, I_b) by:
- For each lighting source, i, we multiply the corresponding components of L_i and R_i.
```
I_ir = R_iraL_ira + R_irdL_ird + R_irsL_irs  (same for g and b)
							 
```

Sum the above values (together with the global ambient component)


I_r = sum-over-i(I_ir) + I_ar  (last is global ambient component)

Still need to figure out reflection values for the various lighting types

Calculating the Ambient Reflection

Intensity is same at all points on surface
Introduce a reflection coefficient, k_a
- 0 <= k_a <= 1 (can't reflect more light than originally)
Thus, I_a = k_aL_a

Calculating the Diffuse Reflection

Characterized by rough surface
Small changes in the angle of light can produce large changes in reflection
A perfectly diffuse surface's roughness is such that there is no preferred angle of reflection
- Known as a Lambertian surface
- In such a surface, the amount of reflection is governed by
  Lambert's law which states that R_d is proportional to cos(θ) where θ is the ngle between the surface normal (vector n) and the direction of the light (vector l).
  - Same light spread over wider surface area produces dimmer reflection
- Remembering that cos(θ) = l · n, and adding in a coefficient (to take into account the proportional), we get:
```
I_d = k_d(l · n)L_d
						
```

Calculating the Specular Reflection

With ambient and diffuse we will get three-D appearance, but dull
Specular reflection will add the highlights
Specular surfaces are smooth
- The smoother the surface the smaller the angles of reflection
While normally a complex calculation, Phong approximates specular reflection with an equation that uses the angle, θ between the viewer vector v and the perfect reflection vector r, a reflection coefficient, and a shininess coefficient, α
- As α increases, the range of angles of reflection gets smaller towards the perfect reflection angle
- As &alpha goes to infinity we get a mirror
  - Values in the range 100 to 500 produce metallic surfaces
  - < 100 gives broad highlights
```
I_s = k_sL_scos^αθ
			
```

Some Final Points

The primary concern was results, not mirroring the laws of optics or physics
In OpenGL, shading is done relatively late in the pipeline
- In the interim, many transformation have been done
- In particular, normals, and more genrally, the cosine vales may not be preserved
- This must be taken into account

Modified Phong

Recall that speular reflection had the term r · v
This term requires recalculation for every vertex
Modified Phong uses a different approximation using the vector halfway between v and l, hich results in a more efficient calculation.
- This vector is known as the halfway vector

Shading in OpenGL

Four types of lighting:
- point
- spotlight
- ambient
- distant
Up to at least 8 light sources
- Each enabled individually
Based on modified Phong

The Functions

glLightModel*(paramName, param)
- Sets a single-valued lighting model parameter
- paramName
  - GL_LIGHT_MODEL_LOCAL_VIEWER
    - Whether view is treated as local-- positioned at origin of eye frame, or infinite (with thus parallel view lines)
    - Infinite viewer simplifies calculate since v is always same-- dealing with direction of viewer, not location
    - parm - is essentially a boolean-- 0 means infinite
  - GL_LIGHT_MODEL_TWO_SIDE
    - Lighting performed for both sides (front and back)
    - parm - basically boolean with 0 meaning one-sided (front only)
glLightModel*v(paramName, * params)
- Sets a multi-valued lighting model parameter
- paramName
- GL_LIGHT_MODEL_AMBIENT
  - parms - four element global RGBA value array
glEnable(GL_LIGHTING)
- Enables lighting calculations
glEnable(GL_LIGHTn)
- Enables light source n, i ranges from 0..7 (at least)
glLight*(light, paraName, param)
- Sets a single-valued light source parameter for specified light
- paramName
  - GL_SPOT_CUTOFF
    - limiting angle of the spotlight (in degrees)
    - 0-90 and 180 accepted (180 means omnidirectional point source)
  - GL_SPOT_EXPONENT
    - The e exponent in the spotlight intensity equation
    - param - 0 - 128 accepted
      - higher exponents - more focused light source
  - GL_CONSTANT_ATTENUATION, GL_LINEAR_ATTENUATION, GL_QUADRATIC_ATTENUATION the a, b,c coefficients of the distance terms, respectively param - non-negative values only
glLight*v(light, paraName, * params) Sets a multi-valued light parameter for specified light paramName GL_POSITION Position/direction of the light source params - four (homogenous) coordinates); if fourth coordinate is 1 (point), we're dealing with light at a particular location; if 0 (vector), we have a directional source (light is treated as coming from an infinite source in a particular direction rather than an actual position-- no distance term is applied GL_SPOT_DIRECTION Direction the spotlight is shining at params - three coordinate direction GL_AMBIENT, GL_DIFFUSE, GL_SPECULAR Sets color intensity of the specified light type param - RGBA value
glMaterial*(face, paramName, param))
- specify single-valued material parameter for specified face
- face
  - GL_FRONT, GL_BACK, GL_FRONT_AND_BACK
- paramName
  - GL_SHININESS
    - Sets value of shininess coefficient for specular light
    - param - 0-128 accepted
glMaterial*v(face, paraName, * params)
- Sets a multi-valued material parameter for specified face
- paramName
  - GL_AMBIENT, GL_DIFFUSE, GLSPECULAR, GL_EMISSION, GL_AMBIENT_AND_DIFFUSE
    - Sets reflectance intensity of corresponding light type(s)
      - GL_EMISSION allows us to have an object emit a color without being a light source.
      - Ambient and diffuse reflectance are often the same, thus the GL_AMBIENT_AND_DIFFUSE value.
    - params - RGBA value