Product Description
A major revision of the international bestseller on game programming!

Graphics hardware has evolved enormously in the last decade. Hardware can now be directly controlled
through techniques such as shader programming, which requires an entirely new thought process of a
programmer. 3D Game Engine Design, Second Edition shows step-by-step how to make a shader-based graphics engine and how to tame the new technology. Much new material has been added, including more than twice the coverage of the essential techniques of scene graph management, as well as new methods for managing memory usage in the new generation of game consoles and portable game players. There are expanded discussions of collision detection, collision avoidance, and physics - all challenging subjects for developers.

*Revision of the classic work on game engines - the core of any game.
* Includes Wild Magic, a commercial quality game engine in source code that illustrates how to build a
real-time rendering system from the lowest-level details all the way to a working game.
* Fully revised and updated in 4 colors, including major new content on shader programming, physics,
and memory management for the next generation game consoles and portables.Amazon.com Review
Aimed at the working Visual C++ game developer, 3D Game Engine Design provides a tour of mathematical techniques for 3-D graphics, and the source code that's used to implement them in state-of-the-art video game engines. If you work in the game industry (or would like to), this book will serve you well, because it delivers excellent best practices for algorithms and programming techniques that'll help your software keep up with the competition.

This text is a virtual encyclopedia of expertise that's based on the author's own work and research in the gaming industry. It provides the mathematical notation, algorithms, and C++ code (on the accompanying CD-ROM) that are needed to build fast and maintainable game engines. Early sections start with the basics, with the math that's used to work with common 3-D objects (like spheres and boxes). Highlights include a high-powered review of quaternion algebra--in many cases, the preferred way to transform 3-D data.

The chapters on graphics pipelines explain the math that's behind representing and rendering a 3-D world in 2-D with intervening effects like lighting and texture mapping. A variety of current algorithms are provided for representing 3-D scenes, efficient picking (which allows a programmer to determine the object in a 3-D world that has been selected), and collision detection (in which objects collide virtually). In the game software of today, curves--and not individual triangles or polygons--often are used to represent 3-D objects. Algorithms that are used to turn curves into rendered surfaces are provided, too.

Later sections look at the current thinking about animation techniques for characters (including key frames, inverse kinematics, and skinning (in which digital skin is fitted over digital bone to create more realistic-looking movement)). How to represent terrain inside virtual worlds also is explained. The book closes with excellent material on such cutting-edge special effects as lens flare and projected shadows, which can add an extra level of realism to a video game. An appendix examines guidelines for designing object-oriented game software in C++.

Filled with mathematical insight and expert code that puts each principle or algorithm to work, 3D Game Engine Design provides an expert view of what goes into building a state-of-the-art game engine. --Richard Dragan

Topics covered:

• Mathematical methods and sample source code for 3-D game development
• Geometrical transformations
• Coordinate systems
• Quaternions
• Euler angles
• Standard 3-D objects: spheres, oriented boxes, capsules, lozenges, cylinders, ellipsoids
• Distance methods for a variety of shapes
• Introduction to the graphics pipeline
• Model and world coordinates
• Projecting perspective
• Camera models
• Culling techniques
• Surface and vertex attributes
• Rasterizing
• Efficiency issues for clipping and lighting
• Hierarchical scene representation, using trees and scene graphs
• Picking algorithms for a variety of 3-D shapes
• Collision detection for static and dynamic graphical objects
• Oriented bounding-box (OBB) trees
• Basics of curves and special curves (including Bezier curves and various splines)
• Curves (generating surfaces from curves by using different techniques)
• Character animation, using keyframe animation and inverse kinematics
• Skinning
• Geometrical level of detail considerations
• Techniques for generating game terrain
• Spatial sorting and binary space partitioning (BSP)
• Special effects: lens flare, bump mapping, volumetric fogging, projected light and shadows, particle systems, morphing techniques
• C++ language features for effective object-oriented design
• Reference to the numerical methods required for game mathematics

Customer Reviews (63)

Pretty good
This book comes with the author's own 3d engine, and the book itself is like extremely detailed documentation about how the engine is put together and why. This is both a good thing and a bad.

The good part is that he walks through the entire engine, piece by piece, and explains in detail how it works and why it was built that way.

The bad part is that in some sections, you get a very narrow view of how to build that piece of the engine. There are many alternative ways to do some of these things, and they're not explored as much.

Overall though, I find the book very good.

robertsjchen
Trust me, this is the book you are finding everywhere if you interesting 3D game designing and have enough mathematics background. it worth to read page by page. ---Chen ShanJun

A thousand pages of pure knowledge!
I began to read this book as soon as I got it, and was amazed instantly. Although I would suggest to first read 3D Math Primer and then get into this book. Because It's way to technichal and mathematicaly oriented. Lots of heavy words.

But it's a title that you MUST have, definitely.

A deceptively titled mathmatical exercise
Identical to the First Edition of this book, the title would have programmers to assume that this text would lead them to designing a game engine; nothing could be further from the truth.
If I gave you rigorous mathematical treatise on transistors and Ohm's law, do you think you could design a radio from it?? Not likely, and certainly NOT practical.This book is well written entertainment for mathematicians (and perhaps source of income to a few)... period. As a "practical approach to Real-Time computer Graphics", it is a fraud.
Anyone seeking to design a 3D engine should consider referencing Tomas Moller's and Eric Haines's book, "Real-Time Rendering" for example, and simply working backward from there which applies simple linear algebra (eg. matrix multiplication, transformation spaces, etc.), and not be lost in the minutia presented in Eberly's treatise.

Everything you need, and then some
This book gives you an excellent foundation upon which you can begin building a game engine.It covers all of the essentials (matrix algebra through artificial intelligence) wonderfully.It isn't so much a cookbook that will show you, step-by-step how to build a game engine, it gives you all of the tools to do so though. ... Read more

Product Description
High Quality Content by WIKIPEDIA articles! Real-time computer graphics is the subfield of computer graphics focused on producing and analyzing images in real time. The term is most often used in reference to interactive 3D computer graphics, typically using a GPU, with video games the most noticeable users. The term can also refer to anything from rendering an application's GUI to real-time image processing and image analysis. Although computers have been known from the beginning (e.g. Bressenham's line drawing algorithm) to be capable of generating 2D images in real-time involving simple lines, images and polygons - 3D computer graphics has always been a daunting task for traditional Von Neumann architecture-based systems to keep up with the speed necessary for generating fast, good quality 3D computer images onto a display screen. The rest of this article concentrates on this widely-accepted aspect of real-time graphics rather than expanding on the principles of real-time 2D computer graphics. ... Read more

Product Description
High Quality Content by WIKIPEDIA articles! A demo is a non-interactive multimedia presentation made within the computer subculture known as the demoscene. Demogroups create demos to demonstrate their abilities in programming, music, drawing, and 3D modeling. The key difference between a classical animation and a demo is that the display of a demo is computed in real time, making computing power considerations the biggest challenge. Demos are mostly composed of 3D animations mixed with 2D effects and full screen effects. The boot block demos of the 1980s, demos that were created to fit within the small (generally 512 to 4096 bytes) first block of the floppy disk that was to be loaded into RAM, were typically created so that software crackers could boast of their accomplishment prior to the loading of the game. What began as a type of electronic graffiti on cracked software became an art form unto itself. ... Read more

Customer Reviews (1)

READ THE PRODUCT REVIEW...
High Quality Content by WIKIPEDIA articles! A demo is a non-interactive multimedia presentation made within the computer subculture known as the demoscene. Demogroups create demos to demonstrate their abilities in programming, music, drawing, and 3D modeling. The key difference between a classical animation and a demo is that the display of a demo is computed in real time, making computing power consid

..... THE WHOLE BOOK IS FROM WIKIPEDIA. ... Read more

Customer Reviews (6)

Broad spectrum of visual tips, techniques and effects!
"GPU Gems" edited by Randima Fernando (Addison-Wesley, 2004, ISBN 0-321-22832-4) is a collection of white papers describing techniques and practical applications useful in today's programmable graphical processing units.The full color hardcover text is 816 pages and includes a CD-ROM that includes working demos and source for most of the articles presented in the book.The text retails for $59.99.

The text is divided into six major parts: natural effects, lighting and shadows, materials, image progressing, performance and practicalities, and beyond triangles.Each part has anywhere between 5 to 9 chapters (for an overall total of 42 chapters).The chapters are separate white papers related to the overall part's major topic.For example, the natural effects part contains chapters on water caustics, Perlin noise, creating realistic fire, and diffraction just to name a few.

Generally, each chapter has an introduction, a background with some mathematics, an implementation occasionally with some partial source code, a conclusion, and key references.While a different author writes each chapter, the overall feel of the book is consistent and smooth.The chapters read very similar to a SIGGRAPH paper without as much math or specific detail.

Take for example, the chapter on stereograms - a process by which a 2D image encodes stereo information that when viewed correctly reveals a 3D scene.The chapter has brief background section that includes several helpful color examples.The author discusses how to create such an image using the fragment program capabilities of a GPU using the z-buffer as a depth map and provides a demo program on the CD.Many of the articles follow the same format - enough of a topic to provide understanding, but not enough depth to be comprehensive or fully instructional.

The topics presented are extremely current.Many of the samples provided on the CD required the latest video hardware (GeForce4 or better) and latest drivers to run.The sample programs and demos require shader support, Cg, OpenGL, or the latest version of DirectX to run.On the plus side, the majority of the companion topics included pre-compiled binaries (but not the runtime dynamic link libraries) or an AVI illustrating the subject in addition to the source code.While the CD contains over 600 MB of examples from the text, it provided only 23 of the 42 topics covered in the book.Since most of the articles provide an overview and references to a topic, additional material on the CD would have been beneficial.

The majority of the contributors are from the Nvidia Corporation which causes the book to bias toward their hardware and developer tools.In fact, one of the chapters is featured FX Composer, Nvidia's shader tool.The source code is a mixture of different shader languages from Microsoft's HLSL to Nvidia's Cg - with various authors using whatever was comfortable or convenient.Although the majority of the material presented is applicable to other hardware, it is critical to have a broad understanding of various shader languages if porting to specific hardware is important.

I found the wide range of subjects quite interesting - and was refreshed that the topics actually seemed "ahead of the curve" in terms of hardware requirements.However in order to provide more subject depth, it seemed that the text could have been split into two volumes in order to expand the existing chapters with sufficient depth.As the material is just enough to get one started, the subject treatment may disappoint some readers seeking to apply the clever and unique techniques presented in the book directly or those hoping to use the book as an opportunity to learn some of the advanced features provided in a programming graphical processing unit.

Very hard to read
Atricles are teribly organaized and nothing is followed through. For instace this book starts with explaination on how to render water. First article indicates that good way to do it would be by summing sin waves and then goes on with derivation. Yet a lot of questions are not answered such is sum of sines is used to represent one wave? multiple waves? all the waves? Graphs that suposed to explain equations are done in 2D, while equations themselfs are in 3D (and difference in drammatic). Then article indicates that sin sums do not represent water waves very well and moves to another equation (which leaves a question of why did they waste time with derivations?) It is also not clear on how this data, from ether equation is going to be used (such as to displace a vertex? or use it for bump mapping, or maybe something else) Other articles seems to bounce a lot too without explaining anything in depth. NVidia examples a tad better (but they cover less interesting points IMHO), thus one star vs zero. There are often no exmples for the topics covered which only makes it harder to understand (for instance i really wanted to see some for article about improving perspective shadow maps). I guess this is expected as good coders are often not so great at writing, but I guess at this price I expected more. Ohh and yes book is very nicely printed, fully in color.

Very good!!!
One of the rare books I found helpfull, it goes through important details and doesn't stop at junks. This book should be a university reference that teach real-time special effects.
I highly advise it to 3D and game programmers.

Wow!
Addison-Wesley and nVIDIA went all out on this book. Every page is color. This means all of the code samples, graphics, everything, is in color. This is not only an impressive trick, it also makes a book on computer graphics a lot easier to read. To understand what a particular algorithm is trying to do with color you needn't go to the center of the book, the graphic is right there.

The content of the book is somewhat mixed. It's done as a collection of papers so the writing tends to vary from verbose to terse. For example the chapter on depth-of-field covers five different techniques in 15 pages with 13 medium to large graphics. That's impressive compression, but it means that it is very terse and the chapter amounts to little more than an overview.The very next chapter, on high-quality filtering, weighing in at 25 pages has a better balance of overview and detail.

Despite it's inconsistencies the book is still a wonderful resource and, frankly, a nice coffee table book to boot. It's even got some unintentionally funny parts, like the section header before page 3 that shows the most un-natural looking monster you have ever seen with the title 'Natural Effects'. Hardly. Still, a great book and a fun read. Bravo AW and nVIDIA.

A Killer Book for HARD CORE Programmers
Hard core graphics programming is definitely an area that separates the men from the boys.If your idea of graphics programming is making a ball bounce across the screen in Flash or Powerpoint, avoid this book.If you are a die hard programmer with a strong mathematical background looking to create some really kick a33 effects, this book is made for you.

The background stuff:There are just under 50 authors that have collaborated to create this book.Just about all of them have a Ph.D from big name schools and I believe every one of them has at least a Master's degree.Most, but not all are folks from NVIDIA.The whole book is about 800 pages including intro/indexes et al.

I really liked the book, but there's two things wrong with it.1)If you don't have a VERY strong background in Graphics programming, you will be utterly clueless what's going on.There's No middle ground. 2)You need a pretty powerful graphics card to work through the examples, which, considering the target audience isn't unfair for them to assume.I have a fairly powerful card on my desktops, but my laptop just doesn't cut it and that's kind of a pain if you read on the run like I do.

As far as negative comments go, that's it.

So what's cool about it?The EFFECTS!Like I mentioned, if there's a cool special effect in a video game or movie, this book shows you how to do it. To summarize a few:

1)Uru:Ages Beyond Myst.If you are familiar with the game and the large bodies of water that are employed, Chapter 1 explains it in depth.There's a good discussion of Gerstner waves , vertex shading and overall simulation models.
2) Fire in the Vulcan.This effect was "Inspired by the Balrog creature in The Lord of the Rings movies, our goal was to display a monster that would be the source of raging flames..."Different variations of this theme have been around for a while and just about any gamer will be familiar with it.It's much more complex than the previously mentioned effect, but it's also more much compelling.
3) Shadow Mapping.Virtually every driving/racing game you've played employs extensive use of Shadow Mapping.The book dedicates 3 Chapters (12, 13 & 14) to the subject and it's discussion is superb.While I don't personally find this the most interesting topic, it's probably the best written area of the book.
4)Glow - Very Very cool.The scenario is the Tron 2.0 video game, but it's absolutely amazing.Although there was very little math here and the discussion was pretty much theory, I had a little (see a LOT) of difficulty re-creating the effects.The code accompanying the book includes everything for the chapter, but recreating my Cityscape wasn't happening.In all fairness though I was pretty excited with the effect and go into coding before reading it another time or two like I should have.
5)One last really impressive area is Filtering.There are many apps where the UI is important but ancillary nonetheless.When I fire up XDesktop, I don't need everything pulsing and glowing doing neat stuff but eating up processor cycles.On the other hand, video games better perform well and anything video centric better be smooth, fast and cool.

All in all I think this book is first rate. The effects absolutely rock, all of them are cool, and the picture quality in the book is superb.Just about every cool effect you'll want to deal with it covered in depth here and you won't leave the table hungry.I really can't emphasize enough though, this isn't a book for hobbyists.Much of the text is written primarily in symbolic math grammar and some of the simpler math involves manipulating Jacobian matricies for instance.If you want to really polish your graphics skills, this book is for you. ... Read more

Customer Reviews (14)

Cg tutorial
This is one of the books highly recommended for learning hardware programming. Found it likewise.

excellent guide to using cg
As the owner of a game company, books like this are a valuable asset in getting our developers who aren't familiar with CG up to speed on the subject.

This book is highly recommended by our development staff, and our developers went out an purchased their own personal copies of the book even though we have it in our office library.

High-grade, low-math intro to vertex shaders
The current generation of GPUs puts a huge amount of rendering power at your fingertips. This book gives a great intro to a range of highly versatile techniques, including bump maps, shadows, complex illumination models, fog, non-realistic rendering, and lots more. You need a little math, but only what's given here. For example, you'll need to know what a dot product is, and the formulas are given. You won't need to know all the extras, like the geometric and trigonometric properties of dot products - those are simply stated where they become useful. Best, the entire discussion is illustrated with simple, legible samples of working code. The cut&paster gets off to a running start. This book really delivers what the title promises: Cg, by means of clear discussion and useful examples.

The book does not deliver what the title does not promise. For example, the authors discuss the effect of finer or coarser tesselation on image quality, but give no idea how to create the geometric models. Because the authors discuss only what goes on inside the GPU, they scarcely mention how to get your shader programs into it, and scarcely mention vertex shaders at all. Those aren't defects in the book, they're choices made by the authors. This book does a lot, but you'll need other references, possibly more than one of them, if you want to build a complete application.

Advanced graphics programmers have probably seen most of this before, and the barest beginners are still struggling with their box's shrink-wrap code samples. If you're ready for the second and third steps of graphics programming, then this could be very helpful. The "gallery" section could be a bit longer and the images a bit bigger, but this is really a how-to book and succeeds nicely in what it set out to do.

-- wiredweird

Good intro to shaders
This is a well written book covering the Cg shading language. It contains a lot of useful information about Cg and graphics programming techniques in general. Unfortunately, I felt like it didn't cover as much of Cg as I would have liked, making the book less useful than it could have been.

The book starts with a history of shaders and programmable hardware, an overview of Cg, and a summary of related technologies, such as HLSL and CgFX. It then spends some time covering the syntax and semantics of Cg, and then moves on to the core material of the book, in which the authors explain key graphics pipeline functionality and how it can be implemented using Cg. The book concludes with several appendices covering the Cg runtime, CgFX file format, and Cg standard library, as well as other reference material.

The topics covered include transformations, animation, lighting, environment mapping, bump mapping, fog, shadow mapping, toon shading, and projective texturing. The explanations are all clear and understandable, in particular the chapter on bump mapping, which is one of the easiest introductions to the topic I've encountered. Features of Cg are introduced as needed while explaining these topics, rather than introducing them all at once, which is very conducive to learning. In addition, the authors include warnings and workarounds for techniques which may not be supported on older hardware, as well as advice on attaining optimal performance.

I have two primary complaints about the book. The first is that they never really discuss the application code using the shaders, which made it a bit difficult to understand how they fit in at times. The second is that the book isn't nearly as complete a reference as you might expect. For a great deal of the functions and functionality in Cg, they simply refer you to the Cg reference manual. Although this electronic document is freely available, it's fairly brief at times, so a more detailed explanation in the book would have been appreciated. Similarly, I would have liked to have seen more detailed explanation of CgFX, as well as examples of using it.

Overall, though, this book does a very good job of introducing the reader to Cg and to shaders in general. If you're new to these topics, I'd recommend it. Even if you're a DirectX programmer intending to use HLSL, you'll find this book useful since the languages are identical (though the usage is of course different). If you're already an experienced graphics programmer with some knowledge of shaders, then you'll likely be able to find everything you need in the freely available documentation instead.

Good introduction to Cg
My review here is from an experienced OpenGL programmer's perspective.

This is an good introduction to the Cg shading language. It goes well beyond the free introductory PDFs on Cg that you can download from the nVidia site, and will quickly bring you up to speed. If you are unfamiliar with the new generation of graphics cards with programmable GPUs, you will love the introductory chapters. There is also an excellent chapter on bump mapping - the best, practical explanation of the technique I have ever seen. (Other books keep harping about tangent space, without explaining *why* you choose tangent space - never mentioning that it *is* possible to do it in object space.)

Now, for a few gripes:

1. There is no clear explanation for how exactly information (say, a calculated light position) should be passed from the vertex program to the fragment program. There are many ways to do this, and there is no suggested way of doing this. (eg: I can use outfloat3 var: POSITION, NORMAL, COLOR0, TEXCOORD0 - which one should I use and why?)

2. The vertex and fragment programs are given as such without any calling code. This may be really tough for beginners.

3. It does not provide a good reference to all the built in Cg functions. In many cases, you have to guess whether a function returns a value or modifes a parameter passed in. For example, there is only 1 line in the book about the faceforward(Ng, I, N) call. What is Ng? Does this function return any value?

4. The utility value of this book will plummet after you go through it once, since it is only an introduction. So I feel it should be priced accordingly. $45 is too much. I recommend getting it used, like I did, for half the price.

I like the book, but it is definitely not in the calibre of the Red book. (The OpenGL programming guide) ... Read more

Product Description
High Quality Content by WIKIPEDIA articles! World War II Frontline Command is a real-time strategy, 3D, tactical war game for the PC that was developed by long standing developers, the Bitmap Brothers. It was originally released in Europe during September 2002 by Deep Silver and subsequently released in June 2003 by Focus Multimedia. As the name suggests, the game is set within the era of World War II. The game opens with the player dropping paratroopers into Europe to disrupt the entrenched Axis forces ahead of the main invasion forces set to land on D-Day. Players must take command of their forces and turn the tide of Axis aggression while conquering fortress Europe, using a vast amount of authentic infantry, vehicles and weaponry. Mission objectives include destroying bridges, clearing bunkers, and knocking down radar towers. There are no resources to be collected or buildings to be constructed. ... Read more

Product Description
Thoroughly revised, this third edition focuses on modern techniques used to generate synthetic three-dimensional images in a fraction of a second. With the advent or programmable shaders, a wide variety of new algorithms have arisen and evolved over the past few years.

This edition discusses current, practical rendering methods used in games and other applications. It also presents a solid theoretical framework and relevant mathematics for the field of interactive computer graphics, all in an approachable style.Amazon.com Review
One would think that the title of Tomas Moller's and EricHaines's book, Real-Time Rendering, would be a contradiction interms. How can such a computationally intensive process as renderingcomputer graphics ever hope to be done on the fly, in the blink of aneye, without delay--in short, in real time?

The termrendering, as it applies to computer graphics, refers to themathematically intensive process of creating a picture or sequence offrames based on geometry. The duration of this process is dependent onthe complexity of the scene (a forest with many trees and thousands ofleaves will take much longer to render than a scene consisting of awhite box over a gray background) and the speed of the hardware doingthe calculations.

When Pixar's Toy Story was firstreleased, the computer animation community was all abuzz with how itwas done, and someone at Pixar mentioned that over 100 SGIworkstations were used for rendering the frames over the course ofalmost two years. Someone else extrapolated this data and figured outthat the same movie could have been rendered on one contemporary PCover the course of about 80 years.

The authors deftly answer thequestion, not only asserting that it can be done, but since this bookis a programmer's guide, they list snippets of programming algorithmsthat help outline how it can be done.

Because the softwareand hardware is constantly and rapidly evolving due to the insatiableneed for more realistic and complex graphics, the book avoids gettingtoo specific. To quote the authors, "The field is rapidly evolving,and so it is a moving target." This lack of specificity doesn'tdetract from the usefulness of the book, though. Instead, it works ata higher, more abstract level, describing approaches to renderingtechniques using generic algorithms. It is up to the programmer toapply these methods to the specific program or system on which it isto be implemented.

Real-Time Rendering describes some verycomplex methods, and this book is not for the average computergraphics creator. However, if you are working in an industry thatdepends on real-time rendered animation--like the gaming, medical, ormilitary fields--or you are building the next-generation real-timerender engine, this book will offer insight and concepts you can useto build some impressive software. --Mike Caputo ... Read more

Customer Reviews (48)

A Must Read and Keep
Four features mark this book as a standout: comprehensive coverage of the subject, clear and supportive figures and illustrations, nicely developed mathematical explanations and descriptions of the phenomena, and usefull cross-references to other textbooks and tech papers. All three editions, together, illustrate the still-ongoing progress in this field. I have used all three as resources for my own work, most recently 3D Modeling, Animation, and Rendering: An Illustrated Lexicon, Color Edition.

Great concept book
I don't know if this book is for you if you are looking for 100% coding examples, but if that's what you're looking for you're probably not interested in Real-Time rendering seriously.

As far as the concepts go though it takes the ideas down to a very solid level of understanding.

My original use for this book was as a textbook over 2 years a go, but I still pull it out to this day.

Marvelous book on rendering
This book is pricey because it's printed on high-quality gloss paper in FULL COLOR. Every illustration, screenshot, is in color, which makes it a real treat to read compared to the usual cheap photocopy paper used in most books. That's all I'll say at this point. I will revise my review after I finish reading it, but at 1000 pages it'll be a short while. I give it 4 stars for now because I don't want to judge a book by it's... layout. ;)

Awesome book!
This book has just the right amount of detail on almost every facet of real-time rendering, and it has 1416 references to point you to more detail when it's needed.Very well written, too.It doesn't have many errors, but it does have a few key ones in some algorithms, so be sure to check the errata list online.

Nice book
It is a great book for people who are going to program in computer graphics. ... Read more

Product Description
This book provides a clear tutorial guide to essential concepts in computer graphics, including state-of-the-art techniques and novel applications such as virtual reality and other forms of 3D interaction. Providing a rich source of examples with which to experiment, and encouraging the development of programming skills, this book is ideal for anyone interested in the study of computer graphics. ... Read more

Product Description
Now that PC users have entered the realm of programmable hardware, graphics programmers can create 3D images and animations comparable to those produced by RenderMan's procedural programs--but in real time. Here is a book that will bring this cutting-edge technology to your computer.

Beginning with the mathematical basics of vertex and pixel shaders, and building to detailed accounts of programmable shader operations, Real-Time Shader Programming provides the foundation and techniques necessary for replicating popular cinema-style 3D graphics as well as creating your own real-time procedural shaders.

A compelling writing style, color illustrations throughout, and scores of online resources make Real-Time Shader Programming an indispensable tutorial/reference for the game developer, graphics programmer, game artist, or visualization programmer, to create countless real-time 3D effects.

* Contains a complete reference of the low-level shader language for both DirectX 8 and DirectX 9
* Provides an interactive shader demonstration tool (RenderMonkeyTM) for testing and experimenting
* Includes a CD ROM containing all shader examples, source code, and tools, plus the DirectX SDK
* Maintains an updated version of the detailed shader reference section at www.directx.com
* Teaches the latest shader programming techniques for high-performance real-time 3D graphics ... Read more

Customer Reviews (7)

OK book on shader programming basics
This book was designed to fill a gap caused by the paradigm shift of going from the fixed-function pipeline found in Direct3D and OpenGL to programming shaders. This book is not a collection of shaders. Instead it explains exactly how shaders work so you can go about creating your own. The first part of the book goes into detail of the mathematics of shading and lighting in an effort to illustrate how a shader can be written. The book does contain shaders, though these tend to be basic building blocks, not complete, focused shaders.
For example, the author discusses the diffuse vs. specular vs. ambient vs. emissive lighting equations and shows how you can use variations of these particular equations to mix and match to get different effects. Creating shaders isn't a cut and paste operation - it's a creative artistic endeavor, and this book gives you the tools and the theoretical knowledge to understand how to create your own. It's not chock full of creative tricks, though there are a few useful ones. It's more an examination of the basic building blocks of shader writing.
The book is focused at both the beginning 3D graphics programmer/artist and the advanced. There's a short section on introductory 3D math such as vertices, points, elementary 3D graphics math, followed by a lengthy chapter on the mathematics of lighting and shading. The book does a good job of explaining the difference between pixel and vertex shading.
Next is a chapter devoted to setting-up Direct3D to use shaders including vertex streams. There's a short chapter on current shader resources that can be found on-lineincluding a tool that the author wrote for the book that illustrates the different methods of handling color over-saturation.
The chapter entitled "shader buffet" is a collection of various shader programsall included on the CDthat illustrate the basics of shader writing and how to code various variations of a theme - Phong specular lighting vs. Blinn specular for example.The final chapter is the DirectX8/DirectX9 shader reference for low-level shader language. The high level language is not covered in this book.The book is full-color throughout, so when the book talks about an effect, it's followed immediately by an image representation.
I gave the book three stars because although well-written, I thought that the mathematics was too elementary for someone who was already into computer graphics to the point that they were ready to tackle writing shaders. Also, I thought that the reference section for the low-level shading language took up space that could have been used for further instruction. However, the material on how to write your own shaders was unique information that is hard to find in the cut and paste books on shaders that are currently in print. Thus it is a worthwhile read, even if it is somewhat expensive for what you are ultimately getting.

Where is the content?
Although some of the content is interesting, if feels like it lacks organization and structure. In addition, half the book is a shader reference which seems to almost be ripped from the Microsoft DirectX documentation

A nice introduction to a complex subject
In "Real-Time Shader Programming", Ron Fosner describes the essential elements necessary for developing shaders in a very approachable full color book that spans just over 400 pages. The book includes a CD with a beta version ATI's RenderMonkey and coded examples of many of the shaders discussed in the text.

Shaders are a relatively new option in the rendering pipeline.By taking explicit control over how vertices and pixels are processed by the graphics hardware, a virtually unlimited number of special effects are available to the programmer.Generally, custom lighting, coloring, or texture mapping are used to create a unique look for an application.

Beginning with elementary vector math, the book moves quickly into lighting theory.The lighting chapter highlights the mathematical approximation of physically based lighting using the traditional ambient, specular, diffuse, and emissive colors in a scene.Representations for reflection and refraction are derived from Snell's Law, and Fresnel equations.Finally, non-photo realistic rendering (from cel shading, tonal art maps, and hatching) is covered through pictures and a wealth of external references.The chapter makes for an enjoyable read by providing an understandable background to lighting techniques to non-seasoned graphics programmers.

Fosner describes how to set up the DirectX pipeline to use shaders.While he touches on some of the nuances you're likely to encounter, the DirectX section seemed a bit sparse compared to the earlier chapters.The DirectX setup calls specific to shaders were well documented, however the chapter didn't dwell on creating the pipeline.

In the subsequent chapter, Fosner discusses several current shader creation and visualization tools.The chapter is relatively short in length perhaps due in part to the volatility and newness of cutting edge shader tools.While high level shader tools, like Nvidia's Cg or Microsoft's High Level Shader Language were briefly mentioned, the book instead focused on the shader language primitives.As such, it provided a sound fundamental shader approach that is universal to all higher-level shader implementations.

Having the groundwork firmly in place, Fosner provides a wealth of shader examples.Starting with the minimal vertex shader, additional functionality is layered to build more complex shaders.Sample shaders are developed using the lighting equations presented earlier.While it may take a little time to digest some of the more sophisticated examples, like the cartoon shader, the text provides adequate descriptive detail coupled with helpful color pictures to make it easier.

The final chapter provides a vertex and pixel command reference.Each command describes the supported shader version, usage, and a short example.The book covers shader implementations for both DirectX 8.x and DirectX 9.Differences between the two versions are noted throughout the sample code and reference section.When appropriate, additional notes on specific DirectX versions are also provided.Fosner does a good job of providing references throughout the book for further information on a subject.

While having familiarity with the rendering pipeline, I found this book very approachable and easy to understand despite not being a low-level graphics programmer.The writing and companion tools provided challenged me to explore the world of shaders and attempt to write some of my own.The tools were a great aid, since it alleviated me from having to write my own engine, and instead focus on the actual shader code.Writing in pseudo-assembly may not seem like fun, but it was - especially when you could experiment with one of the pre-coded routines Fosner supplied and view the results of a vertex or pixel shader routine through RenderMonkey instantly.

Shaders will play an increasingly important role in game development as they allow immense visual flexibility with which to create a unique appearance.Fosner's book presents the introductory groundwork necessary for developing custom shaders.For programmers who are new to shaders or want to experiment with different rendering effects, this book is a great place to start.

Excellent introduction to DirectX shaders
If you know very little about DirectX 8 or 9 shader programming this book is an excellent introduction. It is low level assembly only, no Cg or HLSL, but in my opinion you need to know the assembly programming to ensure the best performance of your shaders. The introductory material is good, covering basic things you should know, ambient, diffuse, specular, and Fresnel equations. The second section builds working shaders implementing these basic concepts. The third section is a shader assembler reference. IMO this book is well written and an easy read.

Disappointing
The first half of this book was on basic computer graphics. The second half wasn't much more than a rewrite of Microsofts DirectX documentation. There were only a few pages of shader techniques that I found useful. ... Read more

Product Description
The control of cameras is as important in games as it is in cinema. How the camera tracks and moves determines our point of view and influences our attitude towards the content. A poorly designed camera system in a game can disrupt a users experience, while a well-designed one can make a good game into a great one. The challenge in games is that the camera must respond to unscripted events, and this is where much of the difficulty of designing real-time camera systems arises. The increasing use of motion in virtual environments, marked by the inclusion of physics modeling and complex collision detection systems, means that camera systems must be even more effective to keep up. Real-Time Cameras is written by an experienced game developer who has written camera control systems for award-winning games such as Metroid Prime. Mark Haigh-Hutchinson discusses the key algorithms for camera control and then shows how to implement them in code. This book is written for game developers and designers, although it is also pertinent to other professionals in the interactive media field. Real-Time Cameras presents a practical approach to camera systems, introducing their theory, design, and implementation.

* The first book on this critical and often poorly understood aspect of game development
* Includes analysis of camera and control systems from existing games along with practical implementation advice
* Discusses the key algorithms with pseudo code examples, and includes movies demonstrating camera technique on the companion CD-ROM ... Read more

Product Description
Based on course notes of SIGGRAPH course teaching techniques for real-time rendering of volumetric data and effects; covers both applications in scientific visualization and real-time rendering. Starts with the basics (texture-based ray casting) and then improves and expands the algorithms incrementally. Book includes source code, algorithms, diagrams, and rendered graphics. ... Read more

Customer Reviews (2)

A very pragmatic book!
While volume graphics have historically been in the realm of scientific visualization, modern GPU's make it possible to render gaseous phenomena such as clouds and fire using true volumetric data in games and simulators at high framerates. Using real-time ray casting to render these objects is quite feasible on modern GPU's, but it's an intimidating-sounding technique.

It really isn't, and this book helps to demystify volumetric rendering using 3D textures, GPU ray-casting, and other techniques. It really isn't hard to understand the concepts; this book presents the math behind it well without going overboard - it's all well-explained.

What's really valuable, however, is all the practical advice stashed in here. If you've experimented with real-time ray casting before, you've likely beaten your head against the wall fighting sampling artifacts, figuring out how to properly add procedural noise to the results, and squeezing enough performance out of your fragment program to not slow down the rest of your scene. If you got past all those hurdles, then you probably gave up when you had to figure out how to deal with intersections between your volume and the rest of your scene, or what to do when the camera goes inside the volume.

This book has chapters on all of those topics, and that's what makes this an invaluable reference for volume graphics that are part of bigger applications. Most of the other research and material on this subject assume you're rendering a single object in isolation, but in a game engine that isn't the case. This book bridges the gap between scientific visualization, games and other visual simulation applications, and finally makes these exciting techniques accessible to a whole new class of applications.

Once it all comes together, the results are truly amazing. You'll find yourself using volume graphics for all sorts of situations and adding an incredible air of reality to your applications as a result. Highly recommended!

It's an advanced computer and game developer's primer important for any comprehensive collection.
Any developer who would work with volume graphics needs this basic text, which provides an introduction to texture-based volume rendering methods, techniques, and optimization routines. Even code examples are included within the examples and technical discussions of generating images from 3D scalar data. It's an advanced computer and game developer's primer important for any comprehensive collection.

Diane C. Donovan
California Bookwatch ... Read more

Product Description
Written by an expert in the game industry, Christer Ericson's new book is a comprehensive guide to the components of efficient real-time collision detection systems. The book provides the tools and know-how needed to implement industrial-strength collision detection for the highly detailed dynamic environments of applications such as 3D games, virtual reality applications, and physical simulators.

Of the many topics covered, a key focus is on spatial and object partitioning through a wide variety of grids, trees, and sorting methods. The author also presents a large collection of intersection and distance tests for both simple and complex geometric shapes. Sections on vector and matrix algebra provide the background for advanced topics such as Voronoi regions, Minkowski sums, and linear and quadratic programming.

Of utmost importance to programmers but rarely discussed in this much detail in other books are the chapters covering numerical and geometric robustness, both essential topics for collision detection systems. Also unique are the chapters discussing how graphics hardware can assist in collision detection computations and on advanced optimization for modern computer architectures. All in all, this comprehensive book will become the industry standard for years to come.

*Presents algorithms and data structures with wide applications to the fields of game development, virtual reality, physically based simulation, CAD/CAM, architectural and scientific visualization, molecular modeling, engineering simulation, GIS, ray tracing, and more.
*Describes tested, real-world methods, liberally illustrated by C & C++ code.
*Reviews necessary concepts from mathematics and computational geometry, and includes extensive references to other sources and research literature. ... Read more

Customer Reviews (21)

Bravi!
If I had to judge this book by its cover, I would have to give it three stars; although the binding is functional, it's one of the ugliest book covers I can remember.Yet the contents between the two covers is splendid, the language is clear, the grammar is correct, and I found not even one spelling mistake.

This book is well-indexed, which makes perfect sense as much of its content is about finding items.I haven't failed to find something I wanted quickly or to locate something I previously read.Citations are well-annotated, and they are complete enough that he cited someone I used to live in the same building with within my first two hours of reading.There are abundant well-drawn figures, and they usually display a high level of helpfulness.

How long does it take to read the entire contents?For me, about ten hours.I am no career mathematician, but I have been writing code nearly three decades and presently writing my third ray tracer.Naturally one can skip through sections where more detail is offered than needed at the time one is reading, but be cautious about this.Some of my most productive reading came from a chapter I didn't plan to (and still don't plan to) need to use.

As a full table of contents for this book is available elsewhere on the Internet, I won't summarize it here--except to say that when I was the table of contents, I ordered the book immediately and had it delivered the next day, which was a Saturday.I started reading Monday and finished Tuesday, and my time and money were well invested.

As I learned to optimize software more than twenty years ago, an unexpected benefit of this book was a lengthy discussion of how to exploit more contemporary hardware and languages, where the effects such as caching, pipelining, and aliasing must be considered, or a terrible drop in performance can result.Sometimes it's good to read some newer material.

Once in a great while, diagram conventions get distracting and require some unscrambling.For example, a diagram showing Andrew's algorithm for computing complex hulls defines "left" and "right" for an edge exactly opposite the reader's perspective.Another example, some binary search trees have their nodes labeled using sequential letters, where the labels indicated have nothing to do with the keys for each node.To one used to seeing nodes of trees marked with their contents, these figures appear at first glance to be incorrect.While they are not incorrect, I find that this choice of labeling is confusing and disrupts the continuity of reading.

The text is almost always perfectly clear and makes everything very simple.The only exception I noticed was the fourth sentence of the chapter "Convexity-based methods".That particular sentence needs a rewrite from scratch, although reading the rest of the paragraph permits one to recover the author's intent.

I didn't even break the seal on the enclosed CD.There is text in the book to say the CD contains the code fragments from the book, with absolutely no additions or other material.Even if it had other material, I still might not open it.

If I had to give this book a letter grade, it would definitely be an A+, although several friends who don't write code seem less enthusiastic about this particular volume.

A must-have
Even though I got this book from another source other than Amazon, I believe it's worth noting that this book is excellent. It is thorough from theory to implementation. It not only contains the theory necessary to implement your own libraries but also tips and secrets one learns by actually coding them --with the advantage the author hands them to us.

Probably this one is to physics/collision detection as Real-Time Rendering, Third Edition is to rendering/computer graphics in general.

The book is an excellent reference and I always have it close to me.

Excellent reference text!
First and foremost a great book.The Author (Christer Ericson) is Director of Technology at SCEA and works on the God of War franchise - so he knows what he's talking about.

The book covers all the relevant and required math for anyone interested in commercial game development.C++ and Object Oriented programming are used throughout.

Chapters are logical and well structured, and the author keeps an up to date blog and website which includes code updates, errata or optimisations.

Academia or anyone involved in computer science or real-time math should read this book!

Great work Christer.

I wish I could have just gotten this in the first place
Even for different domain areas you will come across many of these same issues, not by any means limited to physics. An sort of 3D programming and even database construction and a surprising myriad of computer science problems boil down to the same data structures and for that this book is invaluable. So many times I have waded through pseudocode that had NO english words in it whatsoever and no language constructs from any real langauge, or else a mindless regurgitation of proofs and papers that I don't really care about and aren't relavent to actually DOING anything. Instead I could have just gotten this book and not had to constantly tweak and retweak as I realized yet another issue. In short, I'd not have had to reinvent the wheel nearly so much, and lucky for others if they have this book they will not either.

Geometry bible
I wish I had this book 10 years ago (of course it wasn't written yet).For any numerical analyst that works with data, meshes and/or geometry, this book contains a comprehensive compilation of necessary tools.
The presentation is comprehensible and thorough.
I bought the book for the hierarchical search methods, and I am not disappointed.There are several chapters dedicated to various types of search trees, very well presented. ... Read more

Product Description
Game developers, scientists, engineers, and graphicsprofessionals will find techniques in this book’s four usablesections:

I. Fundamentals: A concise introduction to the science of shading,lighting, and texturing, and the structure of modern graphicshardware.

II. Building Blocks for Shading: Describes algorithms and usefulapproximationsto the fundamental techniques. Documents usual (andunusual) uses of texture coordinates, image compositing, andenvironment maps.

III. High-Level Procedural Shading: Reviews all real-time shadinglanguages and compilers available, as well as shading APIs.

IV. And Beyond: Considers future developments in shading hardware andtheir implications for real-time shading.AUTHORBIO: Marc Olano iscurrently at SGI (Silicon Graphics).He received his Ph.D. from theUniversity of North Carolina.

John C. Hart is an Associate Professor in the Department of ComputerScience at the University of Illinois Urbana-Champaign.

Wolfgang Heidrich is a faculty member of the Computer Science Department at The University of British Columbia.

Michael McCool is an Associate Professor in the Computer Graphics Lab within the Department of Computer Science at the University of Waterloo. ... Read more