1 / 25

Where We Stand

Where We Stand. So far we know how to: Transform between spaces Rasterize Decide what’s in front Next Deciding its intensity and color. Normal Vectors. The intensity of a surface depends on its orientation with respect to the light and the viewer CDs are an extreme example

mcdonaldr
Download Presentation

Where We Stand

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Where We Stand • So far we know how to: • Transform between spaces • Rasterize • Decide what’s in front • Next • Deciding its intensity and color

  2. Normal Vectors • The intensity of a surface depends on its orientation with respect to the light and the viewer • CDs are an extreme example • The surface normal vector describes the orientation of the surface at a point • Mathematically: Vector that is perpendicular to the tangent plane of the surface • What’s the problem with this definition? • Just “the normal vector” or “the normal” • Will use N to denote

  3. Normals and OpenGL glBegin(GL_QUADS); glColor3f(1,1,1); glNormal3f(0,0,1); glVertex3f(1,1,0); glColor3f(1,1,1); glNormal3f(0,0,1); glVertex3f(-1,1,0); glColor3f(1,1,1); glNormal3f(0,0,1); glVertex3f(-1,-1,0); glColor3f(1,1,1); glNormal3f(0,0,1); glVertex3f(1,-1,0); glEnd(); • You must supply per-vertex normal vectors if you enable lighting computations • A common oversight - all surfaces are black and may be invisible • Before specifying each vertex, specify a color and a normal vector: • glColor4f(r, g, b, a) defines a color, with many variants • glNormal3f(x, y, z) defines a normal, with many variants • Chapters 2, 4 and 5 of the OpenGL programming guide have many examples

  4. More Normals and OpenGL glBegin(GL_QUADS); glColor3f(1,1,1); glNormal3f(0,0,1); glVertex3f(1,1,0); glVertex3f(-1,1,0); glVertex3f(-1,-1,0); glVertex3f(1,-1,0); glEnd(); • Specifying fewer colors and normals • OpenGL uses the notion of a current color and a current normal • The current normal is applied to all vertices up to the next normal definition • Normalizing normals • Normal vectors must be unit vectors for lighting to work correctly (they must be normalized) • By default, vectors are not normalized for you • Causes problems with scaling transformations, but OK for translations and rotations • glEnable(GL_NORMALIZE) or glEnable(GL_RESCALE_NORMAL) will fix it for you, but they are expensive and slow rendering

  5. Local Shading Models • Local shading models provide a way to determine the intensity and color of a point on a surface • The models are local because they don’t consider other objects at all • We use them because they are fast and simple to compute • They do not require knowledge of the entire scene, only the current piece of surface

  6. Local Shading Models (Watt 6.2) • What they capture: • Direct illumination from light sources • Diffuse and Specular components • (Very) Approximate effects of global lighting • What they don’t do: • Shadows • Mirrors • Refraction • Lots of other stuff …

  7. “Standard” Lighting Model • Consists of three terms linearly combined: • Diffuse component for the amount of incoming light reflected equally in all directions • Specular component for the amount of light reflected in a mirror-like fashion • Ambient term to approximate light arriving via other surfaces

  8. Diffuse Illumination • Incoming light, Ii, from direction L, is reflected equally in all directions • No dependence on viewing direction • Amount of light reflected depends on: • Angle of surface with respect to light source • Actually, determines how much light is collected by the surface, to then be reflected • Diffuse reflectance coefficient of the surface, kd • Don’t want to illuminate back side. Use

  9. Diffuse Example Where is the light?

  10. Specular Reflection (Phong Model) L V R • Incoming light is reflected primarily in the mirror direction, R • Perceived intensity depends on the relationship between the viewing direction, V, and the mirror direction • Bright spot is called a specularity • Intensity controlled by: • The specular reflectance coefficient, ks • The parameter, n, controls the apparent size of the specularity • Higher n, smaller highlight

  11. Specular Example

  12. Specular Reflection Speedup L V H N • Compute based on normal vector and “halfway” vector, H • Easier to compute than mirror direction • Same result

  13. Putting It Together • Global ambient intensity, Ia: • Gross approximation to light bouncing around of all other surfaces • Modulated by ambient reflectance ka • Just sum all the terms • If there are multiple lights, sum contributions from each light • Several variations, and approximations …

  14. Color • Do everything for three colors, r, g and b • Note that some terms (the expensive ones) are constant • For reasons we will not go into, this is an approximation, but few graphics practitioners realize it • Aliasing in color space • Better results use 9 color samples • Watt discusses it in section 15.4

  15. Approximations for Speed • The viewer direction, V, and the light direction, L, depend on the surface position being considered, x • Distant light approximation: • Assume L is constant for all x • Good approximation if light is distant, such as sun • Distant viewer approximation • Assume V is constant for all x • Rarely good, but only affects specularities

  16. OpenGL Model • Allows emission, E: Light being emitted by surface • Allows separate light intensity for diffuse and specular • Ambient light can be associated with light sources • Allows spotlights that have intensity that depends on outgoing light direction • Allows attenuation of light intensity with distance • Can specify coefficients in multiple ways • Too many variables and commands to present in class • The OpenGL programming guide goes through it all

  17. OpenGL Commands (1) • glMaterial{if}(face, parameter, value) • Changes one of the coefficients for the front or back side of a face (or both sides) • glLight{if}(light, property, value) • Changes one of the properties of a light (intensities, positions, directions, etc) • There are 8 lights: GL_LIGHT0, GL_LIGHT1, … • glLightModel{if}(property, value) • Changes one of the global light model properties (global ambient light, for instance) • glEnable(GL_LIGHT0) enables GL_LIGHT0

  18. OpenGL Commands (2) • glColorMaterial(face, mode) • Causes a material property, such as diffuse reflectance coefficient, to track the current glColor() • Speeds things up, and makes coding easier • glEnable(GL_LIGHTING) turns on lighting • Don’t use specular intensity if you don’t have to • It’s expensive - turn it off by giving 0,0,0 as specular color of light • Don’t forget normals • Many other things to control appearance

  19. Shading Interpolation • The models we have discussed give the intensity of a single point • Computing these models for every point that is displayed is expensive • Normals may not be explicitly stated for every point • Several options: • Flat shading • Gouraud interpolation • Phong interpolation • New hardware does per-pixel programmable shading!!

  20. Compute shading at a representative point and apply to whole polygon OpenGL uses one of the vertices Advantages: Fast - one shading value per polygon Disadvantages: Inaccurate Discontinuities at polygon boundaries Flat shading

  21. Shade each vertex with it’s own location and normal Linearly interpolate across the face Advantages: Fast - incremental calculations when rasterizing Much smoother - use one normal per shared vertex to get continuity between faces Disadvantages: Specularities get lost Gourand Shading

  22. Interpolate normals across faces Shade each pixel Advantages: High quality, narrow specularities Disadvantages: Expensive Still an approximation for most surfaces Not to be confused with Phong’s specularity model Phong Interpolation

  23. Shading and OpenGL • OpenGL defines two particular shading models • Controls how colors are assigned to pixels • glShadeModel(GL_SMOOTH) interpolates between the colors at the vertices (the default) • glShadeModel(GL_FLAT) uses a constant color across the polygon

  24. The Full Story • We have only touched on the complexities of illuminating surfaces • The common model is hopelessly inadequate for accurate lighting (but it’s fast and simple) • Consider two sub-problems of illumination • Where does the light go? Light transport • What happens at surfaces? Reflectance models • Other algorithms address the transport or the reflectance problem, or both • Much later in class, or a separate course

More Related