CSCE 441 Lecture 18

« previous | Monday, February 24, 2014 | next »

Shading / Texturing

Algorithms

Flat shading

Apply same color across entire polygon

• calculate color once per polygon
• center is typically used.

Not very expensive computation

Gouraud Shading

• calculate normals at vertices of polygon
  • average the normals of the surrounding polygons
  • weight averages with area of function
• If all normals are the same, then the result is same as flat shading

• Determine color at each vertex and interpolate across polygon.

Good for diffuse lighting

Moderately expensive computation

Phong Shading

• Assume normals at vertices of polygon
• Interpolate normals from vertices across polygo n
• Determine color at each pixel in polygon

Lot more expensive computation

Interpolating Over Polygons

Given numeric values at vertices of polygon, how do we interpolate data over the interior?

Augment scan conversion algorithm from before:

New Edge data structure:

• maxY = max(y[i], y[i+1])
• currentX = y[i] == min(y[i] + y[i+1]) ? x[i] : x[i+1]
• xIncr = (x[i+1]-x[i]) / (y[i+1] - y[i])
• currentF = y[i] == min(y[i] + y[i+1]) ? f[i] : f[i+1]
• fIncr = (f[i+1]-f[i]) / (y[i+1] - y[i])

When computing entries active edge list,

• currentF += fIncr

When drawing pixels

• calculate value dF = (currentF[i+1] - currentF[i]) / (x[i+1] - x[i]
• F = currentF[i]
• If x is not an integer, multiply F by (1 + (1-x))
• Add dF to x for each step in pixels.

Interpolating Normals

Spherical Linear Interpolation (SLERP)

We want a parameterized normal equation between $n_{0}$ and $n_{1}$ such that $n(t)$ gives the normal with angles $\mathrm {angle} {(n_{0},n(t))}=\theta \,t$ and $\mathrm {angle} {(n_{1},n(t))}=\theta \,(1-t)$ for $t\in [0,1]$.

Length of all vectors are the same (i.e. 1).

We want an equation of the form $n(t)=\alpha \,n_{0}+\beta \,n_{1}$

${\begin{aligned}n_{0}\times n(t)&=\beta \,(n_{0}\times n_{1})&n_{1}\times n(t)&=\alpha \,(n_{1}\times n_{0})\\\left|n_{0}\times n(t)\right|&=\beta \,\left|n_{0}\times n_{1}\right|&\left|n_{1}\times n(t)\right|&=\alpha \,\left|n_{1}\times n_{1}\right|\\n(t)&={\frac {\sin {(\theta \,(1-t))}\,n_{0}+\sin {(\theta \,t)}\,n_{1}}{\sin {\theta }}}\end{aligned}}$

Linear interpolation not correct over perspective projections

Equidistant objects appear closer together as they get farther away in the $z$-direction.

To fix this, we need rational interpolation

Texture Mapping

• Geometry and lighting don't provide sufficient visible detail
• Map a 2D image onto 3D surface.
• 2D image chopped into "charts" to minimize distortion

3D coordinates have corresponding $u$ and $v$ coordinates in image.

• $u,v\in [0,1]$

During polygon drawing, look up color from images and multiply by shading value.

• Nearest neighboring pixel: blocky results
• Linear blending (interpolate value of coordinate from surrounding pixels): smooth appearance
• Can be much more complicated

Other Uses

• Environment Mapping
• Bump/Normal Mapping
• Displacement Mapping
• ...

Any attribute of surface position, normal, color, etc. can be placed in a texture.