cs559: computer graphics
DESCRIPTION
CS559: Computer Graphics. Lecture 16: Shading and OpenGL Li Zhang Spring 2008. Today. Finish transformation in OpenGL Lighting Reading Shirley, Ch 13.3 Ch 9.1, 9.2. 3D Example: A robot arm. Consider this robot arm with 3 degrees of freedom: Base rotates about its vertical axis by - PowerPoint PPT PresentationTRANSCRIPT
CS559: Computer Graphics
Lecture 16: Shading and OpenGLLi Zhang
Spring 2008
Today• Finish transformation in OpenGL• Lighting
• Reading– Shirley, Ch 13.3– Ch 9.1, 9.2
3D Example: A robot arm• Consider this robot arm with 3 degrees of freedom:
– Base rotates about its vertical axis by – Upper arm rotates in its xy-plane by – Lower arm rotates in its xy-plane by
h1
h2 h3
Base
Upper armLower arm
• Q: What matrix do we use to transform the base to the world?• R_y()
• Q: What matrix for the upper arm to the base?• T(0,h1,0)R_z()
• Q: What matrix for the lower arm to the upper arm?• T(0,h2,0)R_z()
z
x
y
x
y
x
3D Example: A robot arm• Consider this robot arm with 3 degrees of freedom:
– Base rotates about its vertical axis by – Upper arm rotates in its xy-plane by – Lower arm rotates in its xy-plane by
h1
h2 h3
Base
Upper armLower arm
• Q: What matrix do we use to transform the base to the world?• R_y()
• Q: What matrix for the upper arm to the base?• T(0,h1,0)R_z()
• Q: What matrix for the lower arm to the upper arm?• T(0,h2,0)R_z()
z
x
y
x
y
x
Shading problem
• Given:– a point P on a surface visible through pixel p– The normal N at P– The lighting direction, L, and intensity, L,at P– The viewing direction, V, at P– The shading coefficients at P
• Compute the color, I, of pixel p.
N L V 1
),0max( NL ddaae LkLkkI
Diffuse Shading
),0max( NL ddaae LkLkkI
Diffuse Shading
),0max( NL ddaae LkLkkI
Specular reflection
• Specular reflection accounts for the highlight that you see on some objects.
• It is particularly important for smooth, shiny surfaces, such as:– Metal, polished stone, plastics, apples, Skin
Specular Reflection
Diffuse Specular
Specular reflection “derivation”
• For a perfect mirror reflector, light is reflected about N, so
• For a near-perfect reflector, you might expect the highlight to fall off quickly with increasing angle .
• Also known as:– “rough specular” reflection– “directional diffuse” reflection– “glossy” reflection
if
0 otherwise
LI
V R
Derivation, cont.
• One way to get this effect is to take (R·V), raised to a power ns.
• As ns gets larger,– the dropoff becomes {more,less} gradual– gives a {larger,smaller} highlight– simulates a {more,less} mirror-like surface
“Iteration three”• The next update to the Phong shading model is
then:
• where:– ks is the specular reflection coefficient
– ns is the specular exponent or shininess
– R is the reflection of the light about the normal (unit vector)
– V is viewing direction (unit vector)
snssddaae LkLkLkkI ),0max(),0max( RVNL
Shininess
Ns=10 Ns=20
Ns=50 Ns=100
Specular vs Diffuse reflection• What’s the key difference Properties:– Specular reflection depends on the viewing
direction V.
Specular Reflection Improvement
• Compute based on normal vector and “halfway” vector, H– Always positive when the light and eye are above the
tangent plane– Not quite the same result as the other formulation
VLVLH / L VNH
snssddaae LkLkLkkI ),0max(),0max( RVNL
pss Lk )( NH
Putting It Together
Phong Shading Model
snssddaae LkLkLkkI )(),0max( NHNL
GLfloat ke[] = { 0.1, 0.15, 0.05, 1.0 };GLfloat ka[] = { 0.1, 0.15, 0.1, 1.0 };GLfloat kd[] = { 0.3, 0.3, 0.2, 1.0 };GLfloat ks[] = { 0.2, 0.2, 0.2, 1.0 };GLfloat ns[] = { 50.0 };glMaterialfv(GL_FRONT, GL_EMISSION, ke); glMaterialfv(GL_FRONT, GL_AMBIENT, ka); glMaterialfv(GL_FRONT, GL_DIFFUSE, kd); glMaterialfv(GL_FRONT, GL_SPECULAR, ks); glMaterialfv(GL_FRONT, GL_SHININESS, ns);
GLfloat ke[] = { 0.1, 0.15, 0.05, 1.0 };GLfloat ka[] = { 0.1, 0.15, 0.1, 1.0 };GLfloat kd[] = { 0.3, 0.3, 0.2, 1.0 };GLfloat ks[] = { 0.2, 0.2, 0.2, 1.0 };GLfloat ns[] = { 50.0 };glMaterialfv(GL_FRONT, GL_EMISSION, ke); glMaterialfv(GL_FRONT, GL_AMBIENT, ka); glMaterialfv(GL_FRONT, GL_DIFFUSE, kd); glMaterialfv(GL_FRONT, GL_SPECULAR, ks); glMaterialfv(GL_FRONT, GL_SHININESS, ns);
Lights• OpenGL supports three different kinds of lights:
ambient, directional, and point. Spot lights are also supported as a special form of point light.
• We’ve seen ambient light sources, which are not really geometric.
• Directional light sources have a single direction and intensity associated with them.
Point lights• The direction of a point light sources is determined by
the vector from the light position to the surface point.
• Physics tells us the intensity must drop off inversely with the square of the distance:
• Sometimes, this distance-squared dropoff is considered too “harsh.” A common alternative is:
• with user-supplied constants for a, b, and c.
E-PL=
E-P
d=E-P
2a+bd +cdatten1
f
2datten1
f
• OpenGL also allows one to apply a directional attenuation of a point light source, giving a spotlight effect.
• The spotlight intensity factor is computed in OpenGL as:
• where– L is the direction to the point light.– S is the center direction of the spotlight.– is the cutoff angle for the spotlight– e is the angular falloff coefficient
Spotlights
espotf 0,arccosmax SL
“Iteration four”• Since light is additive, we can handle multiple lights by
taking the sum over every light.• Our equation is now:
• This is the Phong illumination model in OpenGL.• Which quantities are spatial vectors?
• Which are RGB triples?
• Which are scalars?
j
nssdd
jjj
spot
aaes
jj
j LkLkDcDba
fLkkI )(),0max(
2NHNL
Choosing the parameters• Experiment with different parameter settings. To get you started, here are a
few suggestions:– Try ns in the range [0,100]
– Try ka + kd + ks < 1
– Use a small ka (~0.1)
ns kd ks
Metal largeSmall, color of metal
Large, color of metal
Plastic mediumMedium, color of plastic
Medium, white
Planet 0 varying 0
Shading in OpenGL
• The OpenGL lighting model allows you to associate different lighting colors according to material properties they will influence.
• Thus, our original shading equation becomes:
• where you can have a global ambient light with intensity La in addition to having an ambient light intensity La j associated with each individual light.
j
nssddaa
jjj
spot
aaes
jjj
j LkLkLkDcDba
fLkkI )(),0max(
2NHNL
BRDF• The Phong illumination model is a function that maps
light from incoming (light) directions in to outgoing (viewing) directions out:
• This function is called the Bi-directional Reflectance Distribution Function (BRDF).
• Here’s a plot with in held constant:
• BRDF’s can be quite sophisticated…
( , )outinrf
( , )outinrf in
BRDF measurement
Stanford Graphics Lab
Brdf Viewer plots
Diffuse
written by Szymon Rusinkiewicz
Torrance-Sparrow
Anisotropic
More sophisticated BRDF’s
Westin, Arvo, Torrance 1992
Cook and Torrance, 1982
Gouraud vs. Phong interpolation• Now we know how to compute the color at a
point on a surface using the Phong lighting model.
• Does graphics hardware do this calculation at every point? Typically not (although this is changing)…
• Smooth surfaces are often approximated by polygonal facets. So How do we compute the shading for such a surface?
Faceted shading• Assume each face has a constant normal:
• If we have constant material properties over the surface, how will the color of each triangle vary?
• Result: faceted, not smooth, appearance.
Faceted shading (cont’d)
Gouraud interpolation• To get a smoother result that is easily performed in hardware,
we can do Gouraud interpolation.• Here’s how it works:
1. Compute normals at the vertices.2. Shade only the vertices.3. Interpolate the resulting vertex colors.
Facted shading vs. Gouraud interpolation
Gouraud interpolation artifacts• Gouraud interpolation has significant limitations.– If the polygonal approximation is too coarse, we can
miss specular highlights.
Phong interpolation• To get an even smoother result with fewer
artifacts, we can perform Phong interpolation.• Here’s how it works:
1. Compute normals at the vertices.2. Interpolate normals and normalize.3. Shade using the interpolated normals.
Gouraud vs. Phong interpolation
How to compute vertex normals
triangletriangle
triangletriangletriangle
vertex area
area n
n
A weighted average of normals of neighboring triangles
Compute vertex normals
triangletriangletriangle
triangletriangletriangle
vertex
area
area
n
n
n
A weighted average of normals of neighboring triangles
Define a light in OpenGL
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[] = { 1.0, 1.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);
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[] = { 1.0, 1.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);
snssddaae LkLkLkkI )(),0max( NHNL
GLfloat ke[] = { 0.1, 0.15, 0.05, 1.0 };GLfloat ka[] = { 0.1, 0.15, 0.1, 1.0 };GLfloat kd[] = { 0.3, 0.3, 0.2, 1.0 };GLfloat ks[] = { 0.2, 0.2, 0.2, 1.0 };GLfloat ns[] = { 50.0 };glMaterialfv(GL_FRONT, GL_EMISSION, ke); glMaterialfv(GL_FRONT, GL_AMBIENT, ka); glMaterialfv(GL_FRONT, GL_DIFFUSE, kd); glMaterialfv(GL_FRONT, GL_SPECULAR, ks); glMaterialfv(GL_FRONT, GL_SHININESS, ns);
GLfloat ke[] = { 0.1, 0.15, 0.05, 1.0 };GLfloat ka[] = { 0.1, 0.15, 0.1, 1.0 };GLfloat kd[] = { 0.3, 0.3, 0.2, 1.0 };GLfloat ks[] = { 0.2, 0.2, 0.2, 1.0 };GLfloat ns[] = { 50.0 };glMaterialfv(GL_FRONT, GL_EMISSION, ke); glMaterialfv(GL_FRONT, GL_AMBIENT, ka); glMaterialfv(GL_FRONT, GL_DIFFUSE, kd); glMaterialfv(GL_FRONT, GL_SPECULAR, ks); glMaterialfv(GL_FRONT, GL_SHININESS, ns);
Demo
Light.c
void init(void) { GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 }; GLfloat mat_shininess[] = { 50.0 }; GLfloat light_position[] = { 1.0, 1.0, 1.0, 0.0 }; glClearColor (0.0, 0.0, 0.0, 0.0); glShadeModel (GL_SMOOTH); glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular); glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess); glLightfv(GL_LIGHT0, GL_POSITION, light_position); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glEnable(GL_DEPTH_TEST);
}
void init(void) { GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 }; GLfloat mat_shininess[] = { 50.0 }; GLfloat light_position[] = { 1.0, 1.0, 1.0, 0.0 }; glClearColor (0.0, 0.0, 0.0, 0.0); glShadeModel (GL_SMOOTH); glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular); glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess); glLightfv(GL_LIGHT0, GL_POSITION, light_position); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glEnable(GL_DEPTH_TEST);
}
void display(void) { glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glutSolidSphere (1.0, 20, 16); glFlush ();
}
void display(void) { glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glutSolidSphere (1.0, 20, 16); glFlush ();
}
Light.c
Complex lighting• How to have multiple lights?• How to change lighting positions?• How to change color material?
Multiple lights
GLfloat light1_ambient[] = { 0.2, 0.2, 0.2, 1.0 }; GLfloat light1_diffuse[] = { 1.0, 1.0, 1.0, 1.0 }; GLfloat light1_specular[] = { 1.0, 1.0, 1.0, 1.0 }; GLfloat light1_position[] = { -2.0, 2.0, 1.0, 1.0 }; GLfloat spot_direction[] = { -1.0, -1.0, 0.0 };
glLightfv(GL_LIGHT1, GL_AMBIENT, light1_ambient); glLightfv(GL_LIGHT1, GL_DIFFUSE, light1_diffuse); glLightfv(GL_LIGHT1, GL_SPECULAR, light1_specular);
glLightfv(GL_LIGHT1, GL_POSITION, light1_position); glLightf(GL_LIGHT1, GL_CONSTANT_ATTENUATION, 1.5); glLightf(GL_LIGHT1, GL_LINEAR_ATTENUATION, 0.5); glLightf(GL_LIGHT1, GL_QUADRATIC_ATTENUATION, 0.2); glLightfv(GL_LIGHT1, GL_SPOT_DIRECTION, spot_direction); glLightf(GL_LIGHT1, GL_SPOT_CUTOFF, 45.0); glLightf(GL_LIGHT1, GL_SPOT_EXPONENT, 2.0);
glEnable(GL_LIGHT1);
GLfloat light1_ambient[] = { 0.2, 0.2, 0.2, 1.0 }; GLfloat light1_diffuse[] = { 1.0, 1.0, 1.0, 1.0 }; GLfloat light1_specular[] = { 1.0, 1.0, 1.0, 1.0 }; GLfloat light1_position[] = { -2.0, 2.0, 1.0, 1.0 }; GLfloat spot_direction[] = { -1.0, -1.0, 0.0 };
glLightfv(GL_LIGHT1, GL_AMBIENT, light1_ambient); glLightfv(GL_LIGHT1, GL_DIFFUSE, light1_diffuse); glLightfv(GL_LIGHT1, GL_SPECULAR, light1_specular);
glLightfv(GL_LIGHT1, GL_POSITION, light1_position); glLightf(GL_LIGHT1, GL_CONSTANT_ATTENUATION, 1.5); glLightf(GL_LIGHT1, GL_LINEAR_ATTENUATION, 0.5); glLightf(GL_LIGHT1, GL_QUADRATIC_ATTENUATION, 0.2); glLightfv(GL_LIGHT1, GL_SPOT_DIRECTION, spot_direction); glLightf(GL_LIGHT1, GL_SPOT_CUTOFF, 45.0); glLightf(GL_LIGHT1, GL_SPOT_EXPONENT, 2.0);
glEnable(GL_LIGHT1);
j
nssddaa
jjj
spot
aaes
jjj
j LkLkLkDcDba
fLkkI )(),0max(
2NHNL
Moving light source
• Method 1: – Use glLightfv(GL_LIGHT1, GL_POSITION, light1_position);
• Method 2:– Use transformation
Moving a light source• Use glLightfv(GL_LIGHT1, GL_POSITION, light1_position);
Moving light source• Use transformation
static GLdouble spin; void display(void) {
GLfloat light_position[] = { 0.0, 0.0, 1.5, 1.0 }; glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glPushMatrix();
gluLookAt (0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0); glPushMatrix();
glRotated(spin, 1.0, 0.0, 0.0); glLightfv(GL_LIGHT0, GL_POSITION, light_position);
glPopMatrix(); glutSolidTorus (0.275, 0.85, 8, 15);
glPopMatrix(); glFlush();
}
static GLdouble spin; void display(void) {
GLfloat light_position[] = { 0.0, 0.0, 1.5, 1.0 }; glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glPushMatrix();
gluLookAt (0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0); glPushMatrix();
glRotated(spin, 1.0, 0.0, 0.0); glLightfv(GL_LIGHT0, GL_POSITION, light_position);
glPopMatrix(); glutSolidTorus (0.275, 0.85, 8, 15);
glPopMatrix(); glFlush();
}
Demo• Rotating a light source demo.
glColorMaterial
glEnable(GL_COLOR_MATERIAL);
glColorMaterial(GL_FRONT, GL_DIFFUSE); /* now glColor* changes diffuse reflection */ glColor3f(0.2, 0.5, 0.8); /* draw some objects here */
glColorMaterial(GL_FRONT, GL_SPECULAR); /* glColor* no longer changes diffuse reflection */ /* now glColor* changes specular reflection */ glColor3f(0.9, 0.0, 0.2);
/* draw other objects here */ glDisable(GL_COLOR_MATERIAL);
glEnable(GL_COLOR_MATERIAL);
glColorMaterial(GL_FRONT, GL_DIFFUSE); /* now glColor* changes diffuse reflection */ glColor3f(0.2, 0.5, 0.8); /* draw some objects here */
glColorMaterial(GL_FRONT, GL_SPECULAR); /* glColor* no longer changes diffuse reflection */ /* now glColor* changes specular reflection */ glColor3f(0.9, 0.0, 0.2);
/* draw other objects here */ glDisable(GL_COLOR_MATERIAL);
glColorMaterial• Demo
glColorMaterialvoid mouse(int button, int state, int x, int y) { switch (button) {
case GLUT_LEFT_BUTTON: if (state == GLUT_DOWN) {
/* change red */ diffuseMaterial[0] += 0.1; if (diffuseMaterial[0] > 1.0) diffuseMaterial[0] = 0.0; glColor4fv(diffuseMaterial); glutPostRedisplay();
} break;
case GLUT_MIDDLE_BUTTON: if (state == GLUT_DOWN) {
/* change green */ diffuseMaterial[1] += 0.1; if (diffuseMaterial[1] > 1.0) diffuseMaterial[1] = 0.0; glColor4fv(diffuseMaterial); glutPostRedisplay();
} break;
case GLUT_RIGHT_BUTTON: if (state == GLUT_DOWN) {
/* change blue */ diffuseMaterial[2] += 0.1; if (diffuseMaterial[2] > 1.0) diffuseMaterial[2] = 0.0; glColor4fv(diffuseMaterial); glutPostRedisplay();
} break;
default: break;
} }
void mouse(int button, int state, int x, int y) { switch (button) {
case GLUT_LEFT_BUTTON: if (state == GLUT_DOWN) {
/* change red */ diffuseMaterial[0] += 0.1; if (diffuseMaterial[0] > 1.0) diffuseMaterial[0] = 0.0; glColor4fv(diffuseMaterial); glutPostRedisplay();
} break;
case GLUT_MIDDLE_BUTTON: if (state == GLUT_DOWN) {
/* change green */ diffuseMaterial[1] += 0.1; if (diffuseMaterial[1] > 1.0) diffuseMaterial[1] = 0.0; glColor4fv(diffuseMaterial); glutPostRedisplay();
} break;
case GLUT_RIGHT_BUTTON: if (state == GLUT_DOWN) {
/* change blue */ diffuseMaterial[2] += 0.1; if (diffuseMaterial[2] > 1.0) diffuseMaterial[2] = 0.0; glColor4fv(diffuseMaterial); glutPostRedisplay();
} break;
default: break;
} }
Shading in OpenGL, cont’dNotes:
You can have as many as GL_MAX_LIGHTS lights in a scene. This number is system-dependent.
For directional lights, you specify a light direction, not position, and the attenuation and spotlight terms are ignored.
The directions of directional lights and spotlights are specified in the coordinate systems of the lights, not the surface points as we’ve been doing in lecture.