abrash-black-book/65-04.md

#### The Lessons of Listing 65.3 {#Heading7}

There are several interesting points to Listing 65.3. First,
floating-point arithmetic is used throughout the clipping process. While
it is possible to use fixed-point, doing so requires considerable care
regarding range and precision. Floating-point is much easier—and, with
the Pentium generation of processors, is generally comparable in speed.
In fact, for some operations, such as multiplication in general and
division when the floating-point unit is in single-precision mode,
floating-point is much faster. Check out Chris Hecker's column in the
February 1996 *Game Developer* for an interesting discussion along these
lines.

Second, the planes that form the frustum are shifted ever so slightly
inward from their proper positions at the edge of the field of view.
This guarantees that it's never possible to generate a visible vertex
exactly at the eyepoint, averting the divide-by-zero error that such a
vertex would cause when projected and at no performance cost.

Third, the orientation of the viewer relative to the world is specified
via yaw, pitch, and roll angles, successively applied in that order.
These angles are accumulated from frame to frame according to user
input, and for each frame are used to rotate the view up, view right,
and viewplane normal vectors, which define the world coordinate system,
into the viewspace coordinate system; those transformed vectors in turn
define the rotation from worldspace to viewspace. (See Chapter 61 for a
discussion of coordinate systems and rotation, and take a look at
Chapters 5 and 6 of *Computer Graphics*, by Foley and van Dam, for a
broader overview.) One attractive aspect of accumulating angular
rotations that are then applied to the coordinate system vectors is that
there is no deterioration of the rotation matrix over time. This is in
contrast to my X-Sharp package, in which I accumulated rotations by
keeping a cumulative matrix of all the rotations ever performed;
unfortunately, that approach caused roundoff error to accumulate, so
objects began to warp visibly after many rotations.

Fourth, Listing 65.3 processes each input polygon into a clipped
polygon, one line segment at a time. It would be more efficient to
process all the vertices, categorizing whether and how they're clipped,
and then perform a test such as the Cohen-Sutherland outcode test to
detect trivial acceptance (the polygon is entirely inside) and sometimes
trivial rejection (the polygon is fully outside) without ever dealing
with the edges, and to identify which planes actually need to be clipped
against, as discussed in "Line-Segment Clipping Revisited," *Dr. Dobb's
Journal*, January 1996. Some clipping approaches also minimize the
number of intersection calculations when a segment is clipped by
multiple planes. Further, Listing 65.3 clips a polygon against each
plane in turn, generating a new output polygon for each plane; it is
possible and can be more efficient to generate the final, clipped
polygon without any intermediate representations. For further reading on
advanced clipping techniques, see the discussion starting on page 271 of
Foley and van Dam.

Finally, clipping in Listing 65.3 is performed in worldspace, rather
than in viewspace. The frustum is backtransformed from viewspace (where
it is defined, since it exists relative to the viewer) to worldspace for
this purpose. Worldspace clipping allows us to transform only those
vertices that are visible, rather than transforming all vertices into
viewspace, then clipping them. However, the decision whether to clip in
worldspace or viewspace is not clear-cut and is affected by several
factors.

### Advantages of Viewspace Clipping {#Heading8}

Although viewspace clipping requires transforming vertices that may not
be drawn, it has potential performance advantages. For example, in
worldspace, near and far clip planes are just additional planes that
have to be tested and clipped to, using dot products. In viewspace, near
and far clip planes are typically planes with constant z coordinates, so
testing whether a vertex is near or far-clipped can be performed with a
single z compare, and the fractional distance along a line segment to a
near or far clip intersection can be calculated with a couple of z
subtractions and a divide; no dot products are needed.

Similarly, if the field of view is exactly 90 degrees, so the frustum
planes go out at 45 degree angles relative to the viewplane, then x==z
and y==z along the clip planes. This means that the clipping status of a
vertex can be determined with a simple comparison, far more quickly than
the standard dot-product test. This lends itself particularly well to
outcode-based clipping algorithms, since each compare can set one
outcode bit.

For a game, 90 degrees is a pretty good field of view, but can we get
the same sort of efficient clipping if we need some other field of view?
Sure. All we have to do is scale the x and y results of the
world-to-view transformation to account for the field of view, so that
the coordinates lie in a viewspace that's normalized such that the
frustum planes extend along lines of x==z and y==z. The resulting
visible projected points span the range -1 to 1 (before scaling up to
get pixel coordinates), just as with a 90-degree field of view, so the
rest of the drawing pipeline remains unchanged. Better yet, there is no
cost in performance because the adjustment can be added to the
transformation matrix.

I didn't implement normalized clipping in Listing 65.3 because I wanted
to illustrate the general 3-D clipping mechanism without additional
complications, and because for many applications the dot product (which,
after all, takes only 10-20 cycles on a Pentium) is sufficient. However,
the more frustum clipping you're doing, especially if most of the
polygons are trivially visible, the more attractive the performance
advantages of normalized clipping become.

### Further Reading {#Heading9}

You now have the basics of 3-D clipping, but because fast clipping is
central to high-performance 3-D, there's a lot more to be learned. One
good place for further reading is Foley and van Dam; another is
*Procedural Elements of Computer Graphics*, by David F. Rogers. Read and
understand either of these books, and you'll know everything you need
for world-class clipping.

And, as you read, you might take a moment to consider how wonderful it
is that anyone who's interested can tap into so much expert knowledge
for the price of a book—or, on the Internet, for free—with no strings
attached. Our part of the world is a pretty good place right now, isn't
it?