2. The Graphics Rendering Pipeline (4/4)

Search in book...
Toggle Font Controls
Create new playlist

Name your new playlist

Playlist description (optional)
Sign In

Email address

Password

Forgot Password?

or

Continue with Facebook

Continue with Google
Sign Up

Full Name

Email address

Confirm Email Address

Password

or

Continue with Facebook

Continue with Google

26 2. The Graphics Rendering Pipeline

each object passed to the geometry stage, these two matrices are usually

multiplied together into a single matrix. In the geometry stage the vertices

and normals of the object are transformed with this concatenated matrix,

putting the object into eye space. Then shading at the vertices is computed,

using material and light source properties. Projection is then performed,

transforming the object into a unit cube’s space that represents what the

eye sees. All primitives outside the cube are discarded. All primitives

intersecting this unit cube are clipped against the cube in order to obtain

a set of primitives that lies entirely inside the unit cube. The vertices then

are mapped into the window on the screen. After all these per-polygon

operations have been performed, the resulting data is passed on to the

rasterizer—the ﬁnal major stage in the pipeline.

Rasterizer

In this stage, all primitives are rasterized, i.e., converted into pixels in the

window. Each visible line and triangle in each object enters the rasterizer in

screen space, ready to convert. Those triangles that have been associated

with a texture are rendered with that texture (image) applied to them.

Visibility is resolved via the Z-buﬀer algorithm, along with optional alpha

and stencil tests. Each object is processed in turn, and the ﬁnal image is

then displayed on the screen.

Conclusion

This pipeline resulted from decades of API and graphics hardware evolution

targeted to real-time rendering applications. It is important to note that

this is not the only possible rendering pipeline; oﬄine rendering pipelines

have undergone diﬀerent evolutionary paths. Rendering for ﬁlm production

is most commonly done with micropolygon pipelines [196, 1236]. Academic

research and predictive rendering applications such as architectural previ-

sualization usually employ ray tracing renderers (see Section 9.8.2).

For many years, the only way for application developers to use the pro-

cess described here was through a ﬁxed-function pipeline deﬁned by the

graphics API in use. The ﬁxed-function pipeline is so named because the

graphics hardware that implements it consists of elements that cannot be

programmed in a ﬂexible way. Various parts of the pipeline can be set to

diﬀerent states, e.g., Z-buﬀer testing can be turned on or oﬀ, but there is

no ability to write programs to control the order in which functions are

applied at various stages. The latest (and probably last) example of a

ﬁxed-function machine is Nintendo’s Wii. Programmable GPUs make it

possible to determine exactly what operations are applied in various sub-

stages throughout the pipeline. While studying the ﬁxed-function pipeline

provides a reasonable introduction to some basic principles, most new de-

2.5. Through the Pipeline 27

velopment is aimed at programmable GPUs. This programmability is the

default assumption for this third edition of the book, as it is the modern

way to take full advantage of the GPU.

Table of Contents for 2. The Graphics Rendering Pipeline (4/4)

Create new playlist

Sign In

Sign Up

Table of Contents for
2. The Graphics Rendering Pipeline (4/4)