Upload
others
View
10
Download
0
Embed Size (px)
Citation preview
Chapter 6 Shading 1. Overview 2. Light interactions with matter Light sources Surface types 3. Lighting models Reflection and shading Phong model: Phong reflection + ambient light + diffuse reflection 4. Shading: polygonal shading Flat Phong Gouraud 5. Shading in OpenGL Normals Material properties Light sources 6. Example of sphere (taken from author’s website) _______________________________________________________________________
1. Overview
Why we need shading
• Suppose we build a model of a sphere using many polygons and color it with glColor. We get something like
• But we want
Summary
Color and shading provide depth cues in addition to being object attributes . Light can come from different types of sources and interact with objects having
different optical attributes Lighting models are based on reflection and shading effects that can be modeled
using vector operations When objects are modeled with polygonal faces vector methods make it easy to
compute shading and reflection effects based on the use of the normal to the plane containing the face.
Phong shading is an artificial approach to shading that is simple to implement but does not correspond to physical reality, whereas Gouraud shading is based on optics.
OpenGL supports different types of light sources + materials + Gouraud shading.
2. Light interactions with matter
Why does the image of a real sphere look like ?
• Light-material interactions cause each point to have a different color or shade • Need to consider
Light sources Material properties Location of viewer Surface orientation
Basic principles
Light is a mixture of frequencies in the EM spectrum: R through V visible
The eye is differentially sensitive to wavelengths in the visible spectrum because red, green and blue cones behind the retina have spectral sensitivities respectively centered in the red-yellow region, yellow-green region, and green-blue region.
Objects in scene reflect incident light, photons strike eye. Cells respond to light quanta: quite sensitive, 1 photon is sufficient, 5 to 8 to see flash
The scene observed is the result of a range of interactions of light from different sources with all the objects in the field of view (and possibly some outside).
Shadow Translucent Light source surface M Multiple reflection
Global versus local
• Correct shading requires a global calculation involving all objects and light sources
Incompatible with pipeline model which shades each polygon independently (local rendering)
• However, in computer graphics, especially real time graphics, we are happy if things “look right”
Many techniques for approximating global effects
For example:
• Light strikes A Some scattered Some absorbed
• Some of scattered light strikes B Some scattered Some absorbed
• Some of this scattered light strikes A and so on Rendering Equation
• The infinite scattering and absorption of light can be described by the rendering equation
Cannot be solved in general Ray tracing is a special case for perfectly reflecting surfaces
• Rendering equation is global and includes
Shadows Multiple scattering from object to object
Light-Material Interaction
• The amount reflected determines the color and brightness of the object A surface appears red under white light because the red component of the light is reflected and the rest is absorbed (see figure above)
• The reflected light is scattered in a manner that depends on the smoothness and orientation of the surface
Approximation to physical models of light striking retina
Light sources Ambient Point Diffuse Reflection Perfect Scattered Specular Shading Phong shading Gouraud shading Shadows
Simple Light sources
• Point source Model with position and color Distant source = infinite distance away (parallel)
• Spotlight
Restrict light from ideal point source • Ambient light
Same amount of light everywhere in scene Can model contribution of many sources and reflecting surfaces
Surface types
• The smoother a surface, the more reflected light is concentrated in the direction a perfect mirror would reflected the light
• A very rough surface scatters light in all directions Ideal Reflector
• Normal is determined by local orientation • Angle of incidence = angle of relection • The three vectors must be coplanar
3. Lighting models Effects modeled:
Light sources (point, ambient, diffuse) Material properties Optical effects: Reflection (including Specular Reflection) / Scattering
Ideal reflector
Here the reflection can only be seen if the viewer is situated along the reflected ray.
• Normal is determined by local orientation • Angle of incidence = angle of relection • The three vectors must be coplanar
Relationship is given by
r = 2 (l · n ) n - l Lambertian Surface
• Perfectly diffuse reflector • Light scattered equally in all directions • Amount of light reflected is proportional to the vertical component of incoming
light reflected light ~ cos θi cos θi = l · n if vectors normalized There are also three coefficients, kr, kb, kg that show how much of each
color component is reflected Specular Surfaces
• Most surfaces are neither ideal diffusers nor perfectly specular (ideal reflectors) • Smooth surfaces show specular highlights due to incoming light being reflected in
directions concentrated close to the direction of a perfect reflection specular highlight
Phong model
• This is a simple lighting model that can be computed rapidly • Has three components
Diffuse Specular Ambient
• Uses four vectors To source To viewer Normal Perfect reflector
Specular reflection in Phong model
Uses term that drops off as angle between viewer and ideal reflection increases
Ir ~ ks I cosαφ
shininess coef
absorption coef incoming intensity
reflected intensity
Shininess coefficient = cosα φ
• Values of a between 100 and 200 correspond to metals • Values between 5 and 10 give surface that look like plastic
-90 φ 90
Ambient Light
• Ambient light is the result of multiple interactions between (large) light sources and the objects in the environment
• Amount and color depend on both the color of the light(s) and the material properties of the object
• Add ka Ia to diffuse and specular terms ka = reflection coef Ia = intensity of ambient light Distance Terms
• The light from a point source that reaches a surface is inversely proportional to the square of the distance between them
• Add a factor of the form 1/(ad + bd +cd2) to the diffuse and specular terms • The constant and linear terms soften the effect of the point source
Cumulative Phong model
Light sources
• In the Phong Model, we add the results from each light source • Each light source has separate diffuse, specular, and ambient terms to allow for
maximum flexibility even though this form does not have a physical justification • Separate red, green and blue components • Hence, 9 coefficients for each point source
Idr, Idg, Idb, Isr, Isg, Isb, Iar, Iag, Iab
Material Properties
• Material properties match light source properties
o Nine absorbtion coefficients
kdr, kdg, kdb, ksr, ksg, ksb, kar, kag, kab
o Shininess coefficient α
Adding up the Components For each light source and each color component, the Phong model can be written (without the distance terms) as
I =kd Id l · n + ks Is (v · r )α + ka Ia For each color component we add contributions from all sources
Example of use of Phong model
Differences arise from the parameters used.
4. Shading: polygonal shading To shade a scene shade each polygon in each object by calculating the intensity based on a lighting model such as Phong
• Shading calculations are done for each vertex Vertex colors become vertex shades
Now you have a choice for computing the shade value for each interior (edge or polygon interior):
• By default, vertex shades are interpolated across the polygon glShadeModel(GL_SMOOTH);
• If we use glShadeModel(GL_FLAT); the color at the first vertex will determine
the shade of the whole polygon • Gouraud shading:
Use the average of the normals around a mesh vertex as the normal at the vertex (optically this is not correct but an easy approximation )
n = (n1+n2+n3+n4)/ |n1+n2+n3+n4
Gouraud versus Phong Shading
• Gouraud Shading
Find average normal at each vertex (vertex normals) Apply Phong model at each vertex Interpolate vertex shades across each polygon
• Phong shading
Find vertex normals Interpolate vertex normals across edges Interpolate edge normals across polygon Apply Phong model at each fragment
5. Lighting and Shading in OpenGL What is shading?
Shading is the process of rendering fragments in a graphics model of a scene using a lighting model + a geometric model of objects in the world coordinate system
Geometric model is usually based on polygonal surfaces Real light sources
Finite area
Spectral characteristic
Emission dependent on direction Lighting in OpenGL
Point sources / Spotlights / Ambient sources Located at finite distance / infinity
Each source has diffuse / ambient / specular properties each with
different possible RGB specs Materials for each specified for each surface (back and front) in terms
of how much reflected, transmitted, emitted (because surface can also be a source)
Shading in OpenGL
Lighting model used is for shading one of the following types of polygonal geometry
Flat
Smooth
Gouraud
Steps in OpenGL shading Step 1 Enable lighting
glEnable(GL_LIGHTING);
All colors of objects in scene determined based on light sources
glColor*() not in effect
Enable each light source individually
glEnable(GL_LIGHT0); glEnable(GL_LIGHT1); … Here LIGHT0 has defaults applied to it.
Step 2 Select light model
Specifies model for ambient, local viewer, two-sided surfaces glLightModeli(parameter, value) Here: param is an enumerated type { GL_LIGHT_MODEL_AMBIENT, GL_LIGHT_MODEL_LOCAL_VIEWER, GL_LIGHT_MODEL_TWO_SIDE } and value is boolean: TRUE or FALSE
GL_LIGHT_MODEL_LOCAL_VIEWER = do not use simplifying distant viewer assumption in calculation
GL_LIGHT_MODEL_TWO_SIDED = shades both sides of
polygons independently
Step 3 Specify all normals
In OpenGL the normal vector is part of the state Set normal by
glNormal3f(x, y, z); or glNormal3fv(p);
Specify normal in normalized form or let OpenGL do the normalization automatically:
glEnable(GL_NORMALIZE);
Example: Normal for Triangle n p2 Plane n ·(p - p0 ) = 0 n = (p2 - p0 ) ×(p1 - p0 ) p1 normalize n ← n/ |n| p0 Note that right-hand rule determines outward face.
Step 4 Specify all Light sources glLightv(<source n>, <property>, <value>); Here <source n> is GL_LIGHTn <property> is one of the following: GL_POSITION
GL_AMBIENT GL_DIFFUSE GL_SPECULAR <value> is 4-element array with R, G, B, 0 or 1 or x, y, z, 0 or 1 In the first case: 1 = opaque 0 = translucent In the second: 1 = source at finite distance 0 = source at infinite distance Different types of light sources can be specified in OpenGL:
point source
spotlight
ambient
global ambient
Point Light Source
For each light source, we can set an RGBA for the diffuse, specular, and ambient components, and for the position
GL float diffuse0[]={1.0, 0.0, 0.0, 1.0}; GL float ambient0[]={1.0, 0.0, 0.0, 1.0}; GL float specular0[]={1.0, 0.0, 0.0, 1.0}; Glfloat light0_pos[]={1.0, 2.0, 3,0, 1.0}; glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glLightv(GL_LIGHT0, GL_POSITION, light0_pos); glLightv(GL_LIGHT0, GL_AMBIENT, ambient0); glLightv(GL_LIGHT0, GL_DIFFUSE, diffuse0); glLightv(GL_LIGHT0, GL_SPECULAR, specular0);
Global Ambient Light
Ambient light depends on color of light sources A red light in a white room will cause a red ambient term that
disappears when the light is turned off
OpenGL allows a global ambient term
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, global_ambient);
Step 4 Material Properties
Material properties are also part of the OpenGL state and match the terms in the modified Phong model
Set by glMaterialv()
GLfloat ambient[] = {0.2, 0.2, 0.2, 1.0}; GLfloat diffuse[] = {1.0, 0.8, 0.0, 1.0}; GLfloat specular[] = {1.0, 1.0, 1.0, 1.0}; GLfloat shine = 100.0 glMaterialf(GL_FRONT, GL_AMBIENT, ambient); glMaterialf(GL_FRONT, GL_DIFFUSE, diffuse); glMaterialf(GL_FRONT, GL_SPECULAR, specular); glMaterialf(GL_FRONT, GL_SHININESS, shine);
Step 5 Select shade model: Flat or Gouraud
Set to GL_FLAT or GL_SMOOTH (the latter corresponds to
Gouraud) glShadeModel(GL_FLAT); Default is smooth.
Other considerations Front and Back Faces
• The default is shade only front faces which works correctly for convex objects
• If we set two sided lighting, OpenGL will shade both sides of a surface
• Each side can have its own properties which are set by using GL_FRONT, GL_BACK, or GL_FRONT_AND_BACK in glMaterialf
back faces not visible back faces visible
Guidelines: See
http://www.sjbaker.org/steve/omniv/opengl_lighting.html
6. Example of sphere (taken from author’s website) /* Example 11: eleven-angel.c This program is taken from the book (also on the author's website at www.cs.unm.edu/~angel/BOOK/INTERACTIVE_COMPUTER_GRAPHICS/FOURTH_EDITION/PROGRAMS ). Nothing has been changed. */ /* Recursive subdivision of tetrahedron (Chapter 6). Three display modes: wire frame, constant, and interpolative shading. */ /* program also illustrates defining materials and light sources in init() */ /* mode 0 = wire frame, mode 1 = constant shading, mode 3 = interpolative shading */ #include <stdlib.h> #include <GL/glut.h> typedef float point[4]; /* initial tetrahedron */ float v[][3]={{0.0, 0.0, 1.0}, {0.0, 0.942809, -0.33333}, {-0.816497, -0.471405, -0.333333}, {0.816497, -0.471405, -0.333333}}; static GLfloat theta[] = {0.0,0.0,0.0}; int n; int mode; void triangle( float *a, float *b, float *c) /* display one triangle using a line loop for wire frame, a single normal for constant shading, or three normals for interpolative shading */ { if (mode==0) glBegin(GL_LINE_LOOP); else glBegin(GL_POLYGON); if(mode==1) glNormal3fv(a); if(mode==2) glNormal3fv(a); glVertex3fv(a); if(mode==2) glNormal3fv(b); glVertex3fv(b); if(mode==2) glNormal3fv(c); glVertex3fv(c); glEnd(); } void normal(float *p) {
/* normalize a vector */ double sqrt(); float d =0.0; int i; for(i=0; i<3; i++) d+=p[i]*p[i]; d=sqrt(d); if(d>0.0) for(i=0; i<3; i++) p[i]/=d; } void divide_triangle(float *a, float *b, float *c, int m) { /* Triangle subdivision using vertex numbers. Right-hand rule applied to create outward-pointing faces. */ float v1[3], v2[3], v3[3]; int j; if(m>0) { for(j=0; j<3; j++) v1[j]=a[j]+b[j]; normal(v1); for(j=0; j<3; j++) v2[j]=a[j]+c[j]; normal(v2); for(j=0; j<3; j++) v3[j]=b[j]+c[j]; normal(v3); divide_triangle(a, v1, v2, m-1); divide_triangle(c, v2, v3, m-1); divide_triangle(b, v3, v1, m-1); divide_triangle(v1, v3, v2, m-1); } else triangle(a,b,c); /* draw triangle at end of recursion */ } void tetrahedron( int m) { /* apply triangle subdivision to faces of tetrahedron */ divide_triangle(v[0], v[1], v[2], m); divide_triangle(v[3], v[2], v[1], m); divide_triangle(v[0], v[3], v[1], m); divide_triangle(v[0], v[2], v[3], m); } void display() { /* displays all three modes, side by side */ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glLoadIdentity(); mode=0; tetrahedron(n); mode=1; glTranslatef(-2.0, 0.0,0.0); tetrahedron(n);
mode=2; glTranslatef( 4.0, 0.0,0.0); tetrahedron(n); glFlush(); } void myReshape(int w, int h) { glViewport(0, 0, w, h); glMatrixMode(GL_PROJECTION); glLoadIdentity(); if (w <= h) glOrtho(-4.0, 4.0, -4.0 * (GLfloat) h / (GLfloat) w, 4.0 * (GLfloat) h / (GLfloat) w, -10.0, 10.0); else glOrtho(-4.0 * (GLfloat) w / (GLfloat) h, 4.0 * (GLfloat) w / (GLfloat) h, -4.0, 4.0, -10.0, 10.0); glMatrixMode(GL_MODELVIEW); display(); } void myinit() { GLfloat mat_specular[]={1.0, 1.0, 1.0, 1.0}; GLfloat mat_diffuse[]={1.0, 1.0, 1.0, 1.0}; GLfloat mat_ambient[]={1.0, 1.0, 1.0, 1.0}; GLfloat mat_shininess={100.0}; 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}; /* set up ambient, diffuse, and specular components for light 0 */ glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient); glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse); glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular); /* define material properties for front face of all polygons */ glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular); glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient); glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse); glMaterialf(GL_FRONT, GL_SHININESS, mat_shininess); glShadeModel(GL_SMOOTH); /* enable smooth shading */ glEnable(GL_LIGHTING); /* enable lighting */ glEnable(GL_LIGHT0); /* enable light 0 */ glEnable(GL_DEPTH_TEST); /* enable z buffer */ glClearColor (1.0, 1.0, 1.0, 1.0); glColor3f (0.0, 0.0, 0.0); } int main(int argc, char **argv) {
n=atoi(argv[1]); glutInit(&argc, argv); glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH); glutInitWindowSize(500, 500); glutCreateWindow("sphere"); myinit(); glutReshapeFunc(myReshape); glutDisplayFunc(display); glutMainLoop(); }
Shading type Constant Wireframe Interpolative No of subdivisions of triangle n = 3 n = 5 n = 8