Vertices to Fragments

He reviews two approaches to drawing things.
• Draw on a per object basis (object-oriented)
• Draw on a per pixel basis (pixel-oriented)
• The former is how we do things in the pipeline
• The later is the idea behind ray tracing (or ray casting)
• In object-oriented techniques, we can't really do things like reflections and shadows.
• We have looked at the modeling phase of the pipeline
  • And perhaps more to come.
  • modeling hierarchies (scene graphs)
  • Procedural methods (particle emitters, fractals)
• And the Geometric transformations (a little bit)
  • Projection (Chapter 3)
  • Primitive Assembly - grouping the vertices by the type of object we will be drawing. (points, lines, rectangles, polygons, splines, ...)
  • Clipping - determining the primitives, or parts of primitives which are inside of the view volume, and will be displayed
  • Shading - at the per-vertex level.
  • We will look at clipping in more detail in this chapter.
  • He labels these techniques front end processing
    • Three dimensional calculations
    • Floating point calculations.
    • Rasterization
      • The process of deciding what pixels values will be.
      • This is a two dimensional operation
      • Except a depth value (or z value) will be retained for hidden surface removal methods.
      • This method is also called scan-conversion
      • Colors based on vertex color can be interpolated
      • Or as we have seen, derived in the fragment shader.
      • Most objects are interpolated as line segments at this point in the operation.
      • A transformation from NDC to viewing coordinates must take place.
      • 
      • x_v = x_vmin+ (x+1)/(2.0)(x_vmax-x_vmin)
      • (Similar for y and z if you wish)
      • glViewport(x,y,width,height)
        • By default it is 0,0, width, height of the opened window.
        • But this can be used for multiple views in a single window.
        • This specifies the transformation described above.
        • This can become more complex with multiple views.
        • This is frequently associated with a glutReshapeFunc
          • Which is called when a window geometry change occurs
          • user is given width and height.
          • Default callback is is just glViewport(0,0,width,height)
          • But you might want to

            dim = min(width, height)
            glViewPort(0,0,dim,dim)
            		  

          • Why?
      • Generally this will change us to integer coordinates as they correspond to pixels on a screen.
      • But it doesn't have to.
    • Fragment Processing
      • We have studied coloring on a per fragment basis (somewhat)
      • But we may have to interact with the frame buffer if transparency is a factor.
      • Or we may have to consider textures
      • And we may have to do hidden surface removal.
      • And we may want to eliminate jagged edges.
      • More on this in later.