Browse Books

Reviewer: Paolo E. Sabella

What if generic cheap PC hardware could transform, light, and render 15 million triangles a second__?__ Would that make the task of programming a real-time application as easy as writing a Visual Basic macro in Excel__?__ The answer is no. Although such hardware is now available, there are still many difficult chores left to the programmer of a real-time graphics application. This book presents a systems-level view of how geometry in a scene is tessellated, managed, and sometimes culled and combined with graphics state to render a scene in real time. The focus is neither on geometric modeling nor on animation. Neither is it on the details of low-level graphics algorithms, such as how to scan-convert a triangle. The focus is on real-time rendering, a term for which the authors do not actually provide a definition. In the preface they mention that “this book is about algorithms which create synthetic images fast enough that the viewer can interact with a virtual environment.” The implication is that the synthetic image and virtual environment are three-dimensional, ruling out environments such as those found 20 years ago in real-time video games like PacMan and Asteroids. So this book is about three-dimensional rendering, with varying degrees of photorealism, that is fast enough to be considered real-time. The techniques are distilled across a wide range of system configurations, from the lowly single-CPU PC to the massive parallel processor workstation with high-end graphics. The authors explicitly attempt to avoid concentrating on any one system or API. From a certain point of view, all of graphics seems to be a collection of ad hoc techniques, sometimes referred to as hacks, empirically strung together to achieve specific effects. Therefore, it is only natural that a graphics book reads like an enumeration of one hack after another. It accurately reflects the state of the art. I categorize the material in this book into three types of techniques: mathematical, algorithmic, and hardware. Many techniques are applications of linear algebra, differential geometry, or higher-order geometry. The authors do a decent job of presenting the mathematics necessary to understand and implement them. In most cases, however, readers will be motivated to pursue the extensive reference material provided. For example, chapter 3 contains a reasonable introduction to quaternions, but it states, rather than derives, the conversion to a matrix form, and gives a reference that provides derivation details. Other techniques, such as scene management, culling, intersection, and collision detection, are presented as algorithms. These techniques are mostly implemented on a host CPU. The choice of algorithm is strongly dependent on the application domain. For example, a portal culling technique is applicable for an architectural model, while using impostors may be of benefit to an outdoor scene. The chapters in this category—chapters 7, 10, and 11—provide sweeping coverage of a large number of these techniques, illustrating the open-ended nature of the field. There is no unifying theme across these ad hoc techniques, yet the authors admirably present them in a cohesive fashion. Interestingly, as the exception to my categorization of these as CPU techniques, the authors rightly include triangle strips, fans, and meshes among the speed-up techniques in chapter 7. Techniques in the third category are implemented in hardware. Chapters 4, 5, and 6 present techniques that depend on hardware with features such as multitexturing, multipass rendering, antialiasing, and stencil buffers. The section on generalized texturing in chapter 5 is the best presentation of techniques that use advanced texturing hardware that I have seen to date. These techniques, by their very dependence on hardware, will inevitably be dated with the appearance of newer hardware. The current pace of PC graphics innovation is that the equipment doubles in performance every six months. Hence this book, submitted for publication in March 1999, is significantly out of date already. The consequence of this was clearly foreseen by the authors. For example, today's programmers now have at their disposal a PC graphics solution that is comparable to the SGI InfiniteReality described in chapter 12, the chapter on graphics hardware. Another example of this obsolescence is that the DirectX7 API, and recently available hardware, support non-rigid body transformations, sometimes referred to as skinning, a technique not considered in the book, in addition to hardware support for cube environment mapping. As an overview or survey, this is a valuable reference resource. The book itself is a convenient first reference, with readily available pointers to other references, ranging from Web sites and field publications such as <__?__Pub Fmt italic>Game Developer,<__?__Pub Fmt /italic> to refereed publications such as <__?__Pub Fmt italic>Computer Graphics,<__?__Pub Fmt /italic> books, and the harder-to-locate Ph.D. theses. All in all, it is a must-have for any practitioner or beginner in the field.