Computer Graphics:
Programming, Problem Solving,
and Visual Communication
Steve Cunningham
California State University Stanislaus and Grinnell College
PowerPoint Instructor’s Resource
The Rendering Pipeline
How the OpenGL system creates
the image from your modeling
A Different Perspective on
Creating Images
• Up to this point we have focused on the
content of images, without much
thought about how they are created
• Rendering is the process of taking the
descriptions you have provided and
setting the appropriate pixels to the
appropriate colors to create the actual
image
The Rendering Pipeline
• Rendering is accomplished by starting
with your modeling and applying a
sequence of operations that become
more and more detailed: a pipeline
• This chapter is really about the steps in
that pipeline: what they are and how
they are done
The Rendering Pipeline (2)
• The basic steps in the pipeline are:
• You will recognize many of the pieces
from earlier chapters
The Rendering Pipeline (3)
• The steps can happen in different ways
– Software-only
– On a graphics card
• OpenGL only specifies the process, not
the implementation
Two Parts to the Pipeline
• The first part of the pipeline is the
Geometry Pipeline
• This works on the geometry you define
and takes it to screen space
• The second part of the pipeline is the
Rendering Pipeline
• This takes the basic geometry in screen
space and actually sets all pixels
Model Space
• The actual definition of your graphics
objects happens in model space when
you define
• The vertices of your object - glVertex(…)
• The way these vertices are grouped glBegin(…) - glEnd()
Model Space to World Space
• The vertices you defined are transformed
through the modeling transformation that
is currently active, and the results are
vertices in world space
• Grouping information is passed along
• Light position can be affected if this is
defined within your modeling
World Space to 3D Eye Space
• The viewing transformation is applied to
all points in world space in order to
transform them into 3D eye space
• In OpenGL, the modeling and viewing
transformations are combined into the
modelview transformation, and this is
what is really applied
• Grouping is passed along
3D Eye Space to Screen Space
• This is performed by the projection
transformation
• Much more than geometry is done, however!
– The glColor statement or lighting model give the
point a color
– The z-value in eye space is used to compute a
depth
– Clipping on the view volume is performed so only
visible geometry is preserved
– Grouping is passed along
A Point in Screen Space
• A point is screen space corresponds to
a pixel, but it also has a number of
properties that are needed for rendering
– Position
– Depth
– Color - RGB[A]
– Texture coordinates
– Normal vector
Rendering
• To begin the rendering process, we have
“pixels with properties” for each vertex of
the geometry
• The first step is to proceed from vertices to
edges by computing the pixels that bound
the graphics objects
• The edges are determined by the grouping
you defined as part of your modeling
Computing Edges
• Edges are computed by interpolation
– Geometric interpolation, such as the
Bresenham algorithm, is used to compute
the coordinates of each pixel in the edge
– There are rules about edge computation that
avoid including pixels that keep from
including any pixel in two different edges and
that do not include any horizontal edge
Computing Edges (2)
• The interpolation is deeper than pixels
– The geometry interpolation is extended to
calculate the color, depth, texture
coordinates, and normal for each edge
pixel
– If the projection used perspective, this also
needs to be used to interpolate depth and
texture
Result of Edge Computation
• The result of the edge computation is a
set of edges for each graphical object
• Because OpenGL only works with
convex objects, and because of the
rules about including pixels in edges, for
any horizontal line of pixels there are
either zero or two edges that meet this
line
Fragments
• If there are exactly two edges that meet
a horizontal line of pixels, we need to
determine the color of all pixels between
the two edge pixels on the line
• These pixels are called a fragment
Fragments (2)
• To determine the color of each pixel,
– Interpolate from left to right on the line
– For each pixel,
• Calculate the depth
• Calculate the color (interpolate the color or use
the texture)
• If depth testing, check the depth in depth buffer
• If masking, check against mask
• If the pixel passes the depth and mask tests
– Perform any blending needed
– Write the new color and depth to the color and depth
buffers
Some OpenGL Details
• The overall OpenGL system model
Some OpenGL Details (2)
• Processing for texture maps
Some OpenGL Details (3)
• Detail of fragment processing
Programmable Shaders
• The OpenGL system model shown here
uses a fixed-function pipeline where all
the operations are already defined
• This is being expanded to a pipeline that
lets you define some of the functions by
adding programs, called shaders, that
you can define
• These shaders can be applied as a few
specific places in the pipeline
Three Programmable Stages
Geometry Shaders
• Geometry shaders work as the primitives
(vertices plus groupings) are defined
• They will allow you to extend the original
geometry with additional vertices or
groups
Vertex Shaders
• Vertex shaders let you manipulate the
individual vertices before they are
passed to the rasterization stages
Fragment Shaders
• Fragment shaders let you manipulate
individual pixels to apply new algorithms
to color or select pixels
Shaders Are New…
• … and are beyond the scope of a
beginning graphics course at this time
• If you have a shader-capable graphics
card and a shader-capable OpenGL
system, it will be interesting for you to
experiment with them once your
OpenGL skills are solid
• We suggest that you use Mike Bailey’s
glman system as a learning tool