Week 7 wednesday
1 / 28

CS361 - PowerPoint PPT Presentation

  • Uploaded on

Week 7 - Wednesday. CS361. Last time. What did we talk about last time? Specular shading Aliasing and antialiasing. Questions?. Project 2. Student Lecture: Transparency. Transparency. Transparency.

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
Download Presentation

PowerPoint Slideshow about ' CS361' - joie

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.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

Last time
Last time

  • What did we talk about last time?

  • Specular shading

  • Aliasing and antialiasing


  • Partially transparent objects significantly increase the difficulty of rendering a scene

  • We will talk about really difficult effects like frosted glass or light bending later

  • Just rendering transparent objects at all is a huge pain because the Z-buffer doesn't work anymore

  • Workarounds:

    • Screen door transparency

    • Sorting

    • Depth peeling

Screen door transparency
Screen door transparency

  • We render an object with a checkerboard pattern of holes in it, leaving whatever is beneath the object showing through

  • Problems:

    • It really only works for 50% transparent


    • Only one overlapping

      transparent object really works

  • But it is simple and inexpensive

Over operator
Over operator

  • Most transparency methods use the over operator, which combines two colors using the alpha of the one you're putting on top

  • c0 = αscs + (1 - αs)cd

    • cs is the new (source) color

    • cd is the old (destination) color

    • co is the resulting (over) color

    • αs is the opacity (alpha) of the object


  • The over operator is order dependent

  • To render correctly we can do the following:

    • Render all the opaque objects

    • Sort the centroids of the transparent objects in distance from the viewer

    • Render the transparent objects in back to front order

  • To make sure that you don't draw on top of an opaque object, you test against the Z-buffer but don't update it

Problems with sorting
Problems with sorting

  • It is not always possible to sort polygons

    • They can interpenetrate

  • Hacks:

    • At the very least, use a Z-buffer test but not replacement

    • Turning off culling can help

    • Or render transparent polygons twice:

      once for each face

Depth peeling
Depth peeling

  • It is possible to use two depth buffers to render transparency correctly

  • First render all the opaque objects updating the first depth buffer

    • Make second depth buffer maximally close

  • On the second (and future) rendering passes, render those fragments that are closer than the z values in the first depth buffer but further than the value in the second depth buffer

    • Update the second depth buffer

  • Repeat the process until no pixels are updated

Other alpha effects
Other alpha effects

  • Alpha values can be used for antialiasing, by lowering the opacity of edges that partially cover pixels

  • Additive blending is an alternative to the over operator

    • c0 = αscs + cd

    • This is only useful for effects like glows where the new color never makes the original darker

    • Unlike transparency, it can be applied in any order


  • I don't want to go deeply into gamma

  • The trouble is that real light has a wide range of color values that we need to store in some limited range (such as 0 – 255)

  • Then, we have to display these values, moving back from the limited range to the "real world" range

Gamma correction1
Gamma correction

  • Physical computations should be performed in the linear (real) space

  • To convert that linear space into nonlinear frame buffer space, we have to raise values by a power, typically 0.45 for PCs and 0.55 for Macs

  • Each component of physical color (0.3, 0.5, 0.6) is raised to 0.45 giving (0.582, 0.732, 0.794) then scaled to the 0-255 range, giving (148, 187, 203)

Gamma errors
Gamma errors

  • Usually, gamma correction is taken care of for you

  • If you are writing something where you need to do computations in the "real life" color space (such as a raytracer), you may have to worry about it

  • Calculations in the wrong space can have visually unrealistic effects


  • We've got polygons, but they are all one color

    • At most, we could have different colors at each vertex

  • We want to "paint" a picture on the polygon

    • Because the surface is supposed to be colorful

    • To appear as if there is greater complexity than there is (a texture of bricks rather than a complex geometry of bricks)

    • To apply other effects to the surface such as changes in material or normal

Texture pipeline
Texture pipeline

  • Transformed value

  • We never get tired of pipelines

    • Go from object space to parameter space

    • Go from parameter space to texture space

    • Get the texture value

    • Transform the texture value

Projector function
Projector function

  • The projector function goes from the model space (a 3D location on a surface) to a 2D (u,v) coordinate on a texture

  • Usually, this is based on a map from the model to the texture, made by an artist

    • Tools exist to help artists "unwrap" the model

    • Different kinds of mapping make this easier

  • In other scenarios, a mapping could be determined at run time

Corresponder function
Corresponder function

  • From (u,v) coordinates we have to find a corresponding texture pixel (or texel)

  • Often this just maps directly from u,v [0,1] to a pixel in the full width, height range

  • But matrix transformations can be applied

  • Also, values outside of [0,1] can be given, with different choices of interpretation

Texture values
Texture values

  • Usually the texture value is just an RGB triple (or an RGBα value)

  • But, it could be procedurally generated

  • It could be a bump mapping or other surface data

  • It might need some transformation after retrieval

Next time
Next time…

  • Image texturing techniques

  • Procedural texturing


  • Keep working on Project 2

    • Due this Friday, March 1

  • Keep reading Chapter 6