11/5/2002 (c) university of wisconsin, cs 559 last time local shading –diffuse term –specular...

11/5/2002 (c) University of Wisconsin, CS 559

Last Time

• Local Shading– Diffuse term– Specular term– All together– OpenGL brief overview


Today

• Shading Interpolation• More on light sources• Texture Mapping• Homework 4 due


• So far, we have discussed illuminating a single point

• We have assumed that we know:– The point– The surface normal– The viewer location (or direction)– The light location (or direction)

• But commonly, normal vectors are only given at the vertices• It is also expensive to compute lighting for every point

Shading so Far

psdiaa kkIIkI )()( NHNL


Shading Interpolation

• Several options:– Flat shading– Gouraud interpolation– Phong interpolation

• New hardware provides other options


Flat shading• Compute shading at a

representative point and apply to whole polygon– OpenGL uses one of the vertices

• Advantages: – Fast - one shading computation

per polygon, fill entire polygon with same color

• Disadvantages:– Inaccurate– What are the artifacts?


Gouraud Shading• Shade each vertex with it’s own

location and normal• Linearly interpolate the color

across the face• Advantages:

– Fast - incremental calculations when rasterizing

– Much smoother - use one normal per shared vertex to get continuity between faces

• Disadvantages:– What are the artifacts?– Is it accurate?


Phong Interpolation• 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


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, Gouraud shading)– glShadeModel(GL_FLAT) uses a constant color across the

polygon


The Current Generation

• Current hardware allows you to break from the standard illumination model

• Programmable Vertex Shaders allow you to write a small program that determines how the color of a vertex is computed– Your program has access to the surface normal and position, plus

anything else you care to give it (like the light)– You can add, subtract, take dot products, and so on


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


Light Sources• Two aspects of light sources are important for a local

shading model:– Where is the light coming from (the L vector)?– How much light is coming (the I values)?

• Various light source types give different answers to the above questions:– Point light source: Light from a specific point– Directional: Light from a specific direction– Spotlight: Light from a specific point with intensity that depends on

the direction– Area light: Light from a continuum of points (later in the course)


Point and Directional Sources

• Point light: L(x) = ||plight - x||– The L vector depends on where the surface point is located– Must be normalized - slightly expensive– To specify an OpenGL light at 1,1,1:

• Directional light: L(x) = Llight

– The L vector does not change over points in the world– OpenGL light traveling in direction 1,1,1 (L is in opposite direction):

Glfloat light_position[] = { 1.0, 1.0, 1.0, 1.0 };glLightfv(GL_LIGHT0, GL_POSITION, light_position);

Glfloat light_position[] = { 1.0, 1.0, 1.0, 0.0 };glLightfv(GL_LIGHT0, GL_POSITION, light_position);


Spotlights

• Point source, but intensity depends on L:– Requires a position: the location of the source

– Requires a direction: the center axis of the light

– Requires a cut-off: how broad the beam is

– Requires and exponent: how the light tapers off at the edges of the cone

• Intensity scaled by (L·D)n

glLightfv(GL_LIGHT0, GL_POSITION, light_posn);

glLightfv(GL_LIGHT0, GL_SPOT_DIRECTION, light_dir);

glLightfv(GL_LIGHT0, GL_SPOT_CUTOFF, 45.0);

glLightfv(GL_LIGHT0, GL_SPOT_EXPONENT, 1.0);

cut-off

direction


Mapping Techniques

• Consider the problem of rendering a soup can– The geometry is very simple - a cylinder– But the color changes rapidly, with sharp edges– With the local shading model, so far, the only place to specify color

is at the vertices– To do a soup can, would need thousands of polygons for a simple

shape– Same thing for an orange: simple shape but complex normal vectors

• Solution: Mapping techniques use simple geometry modified by a mapping of some type


Texture Mapping

• The soup tin is easily described by pasting a label on the plain cylinder

• Texture mapping associates the color of a point with the color in an image: the texture– Soup tin: Each point on the cylinder get the label’s color

• Question to address: Which point of the texture do we use for a given point on the surface?

• Establish a mapping from surface points to image points– Different mappings are common for different shapes– We will, for now, just look at triangles (polygons)


Basic Mapping• The texture lives in a 2D space

– Parameterize points in the texture with 2 coordinates: (s,t)– These are just what we would call (x,y) if we were talking about an

image, but we wish to avoid confusion with the world (x,y,z)• Define the mapping from (x,y,z) in world space to (s,t) in

texture space– To find the color in the texture, take an (x,y,z) point on the surface,

map it into texture space, and use it to look up the color of the texture• With polygons:

– Specify (s,t) coordinates at vertices– Interpolate (s,t) for other points based on given vertices


Example Mappings


Texture Interpolation• Specify where the vertices in

world space are mapped to in texture space

• Linearly interpolate the mapping for other points in world space– Straight lines in world space go

to straight lines in texture space Texture maps

t

Triangle in world space


Interpolating Coordinates

(x1, y1), (s1, t1)(x2, y2), (s2, t2)

(x3, y3), (s3, t3)

313

11

13

11 syyyys

yyyysR

3

23

22

23

21 syyyys

yyyysL

RLR

LL

LR

L sxxxxs

xxxxs

1


Pipelines and Texture Mapping

• Texture mapping is done in canonical screen space as the polygon is rasterized

• When describing a scene, you assume that texture interpolation will be done in world space

• Which property of perspective projection means that the “wrong thing” will happen if we apply our simple interpolations from the previous slide?

• Perspective correct texture mapping does the right thing, but at a cost

• Is it a problem with orthographic viewing?


Basic OpenGL Texturing• Specify texture coordinates for the polygon:

– Use glTexCoord2f(s,t) before each vertex:• Eg: glTexCoord2f(0,0); glVertex3f(x,y,z);

• Create a texture object and fill it with texture data:– glGenTextures(num, &indices) to get identifiers for the objects– glBindTexture(GL_TEXTURE_2D, identifier) to bind the texture

• Following texture commands refer to the bound texture– glTexParameteri(GL_TEXTURE_2D, …, …) to specify parameters

for use when applying the texture– glTexImage2D(GL_TEXTURE_2D, ….) to specify the texture data

(the image itself)

MORE…


Basic OpenGL Texturing (cont)• Enable texturing: glEnable(GL_TEXTURE_2D)• State how the texture will be used:

– glTexEnvf(…)• Texturing is done after lighting• You’re ready to go…

11/5/2002 (c) university of wisconsin, cs 559 last time local shading –diffuse term –specular...

Documents