Special Effects Game Programming with DirectX w/CD (The Premier Press Game Development Series)

I've been looking forward to this book for a long time now. I've attended several industry conferences with the author, and he's written numerous articles for our website, so I know him to be both an excellent game programmer and talented writer. I had high expectations for this book, and I'm happy to report that it not only lives up to them, it exceeds them.This book does two things very well: it provides first-rate coverage of DirectX, and it provides the most extensive coverage of special effects ever put in to a game programming book. I'm going to review each of these aspects of the book separately.The first half of this book is dedicated to covering the basics of Windows programming, 3D math, and DirectX, and it makes the assumption that you're new to all of these areas. He covers all components of the DirectX API, including DirectAudio, DirectInput, DirectPlay, DirectShow, and of course, DirectGraphics (aka Direct3D), which is where the book really shines. Before this book, I had not encountered a single Direct3D book which I could recommend without reservation. He dedicates 5 hefty chapters to DirectGraphics, including two on texture mapping and one on pixel and vertex shaders (and that doesn't count the second half of the book which provides plenty of examples and advanced techniques). Simply put, this is without question the best book currently on the market from which to learn DirectX, and for that reason alone, it's earned a place at the top of my recommendations list.Note that even if you aren't new to DirectX, you'll probably find a lot of useful things in the first half of the book which are generally omitted from or glossed over in (most) other books, such as action mapping, DirectShow, and DirectPlay. Even the 3D math section has something to offer, with the most concise and accessible explanation of quaternions that I've come across.The special effects section of the book is divided into two parts. The first covers 2D effects, including fire, water, image feedback, image warping, clouds, blurs, and transitions. Before you complain about 2D being a thing of the past, note that these effects are intended for use in title screens, or for generating textures to be used in 3D worlds. The second part is, of course, 3D effects, and includes particle systems, explosions, 3D water, guns and projectiles, lens flares, and vertex and pixel shader effects. All of these are presented quite well, but the particle system coverage deserves special mention. It spans almost 100, and takes you all the way from a basic system to a powerful, flexible system controlled through scripts.Each special effect is accompanied by at least one demo program, which is thoroughly explained in the book. The only downside to this is that the author was only able to focus on a single algorithm for each effect, but he at least mentions some of the alternative approaches, as well as suggestions for improving the techniques he presents. Overall, any game programmer should be able to benefit from the special effects portion of the book, even if you've done some of these things before.My only real complaint about this book is that it should have been two books. Experienced game programmers will probably find a lot they can use in the special effects portion of the book, but may find the DirectX portion unnecessary. Beginning programmers will definitely benefit from the DirectX portion, but may want to spend some time working on basic game techniques before diving into the special effects portion. But, it's not two books, and as a single volume, it's still worth the price. Also, you should be aware that some of the effects covered in this book require a newer video card to even be able to run the demo program. To get the most out of the book, you'll need a card that at least supports vertex shaders, and preferably pixel shaders as well. Also, if you're not pretty comfortable with C++, you may find yourself struggling with some of the code.Overall, this book is extremely well-written and easy to read. There's so much that this book has to offer that is difficult, if not impossible, to find elsewhere, I strongly recommend it as a must-have for anyone interested in game programming.

Not enough detail on things that need more explanation and too much on concepts that will be familiar to most readers, such as basic 3D Math. There seems to be a definite lack of focus -- readers who need a primer on 3D concepts are not likely to be the ones reading about pixel shaders, so why have both and not do justice to either? Things like environment mapping and vertex shaders should have been covered in much greater detail and with more annotated code in the book. There are a couple of skimpy equations for cubic and spherical environment mapping and not much else. The book mentions bump mapping at one point but not how to implement it. It's almost as if the original version of the book was too long so they removed parts at random. Finally, any book which does not respect the readers' intelligence is a bad book in my opinion - this book is littered with statements like "Don't worry about the math, do this and this and you'll get this result." He says this even in the chapter on vertex and pixel shaders when understanding the math behind the fixed-function T&L pipeline is absolutely essential to writing your own shaders! I had reasonably high expectations of this book but it seems suitable only for people who want to make minor tweaks to the sample code and pass it off as their own program. Poor.

It's very hard to find accessible books on visual effect algorithms these days. Everyone just expects you to buy the latest software and pull down the appropriate menu and not worry about the math. For those of you who want something between yet another book on basic computer graphics and inaccessible tomes on visual effects that are written by academics for academics, this out of print book fits the bill. The DirectX info is probably largely out of date, but the last half of the book on special effects is done in language-independent way so that it serves as a tutorial on algorithm details regardless of what language you are working on. The book is written so that you can skip to the special effect you are interested in and get a well written and well illustrated short tutorial on most of the basics - lens flare, clouds, fire, water, lighting, etc. Since the book is only sold used, make sure you get a copy with the CD because there is a wealth of material on it including complete code. The book really isn't a standalone anything, but it will make a good complement to the other books on game/special effects programming you have in your library even at its advanced age.

This book makes understanding the complex world of modern computer graphics and the DirectX library as simple as they can be. This title will be an invaluable resource for anyone with a C programming background (or beyond) who wants to become intimitely familiar with the DirectX library for rendering computer graphics. It's heavily slanted towards Windows game programming but the concepts carry over to other domains as well. The book spends time giving background on some of the more useful C++ language features, including stl, utilized in most modern computer games. It also provides an overview of the entire DirectX toolkit: DirectPlay, DirectSound, etc... There's a crash course on the fundamentals of vector/matrix math and basic 3D graphics concepts that are required for a software engineer to really use Direct3D effectively. An experienced C++ graphics programmer can skip over all this and dive right into the advanced graphics features of transform & lighting, pixel and vertex shaders, texture blending effects, etc... The great thing about this title is the way it spends time on motivations and examples so the concepts don't get lost due to their complexity. Simply put if you're a Windows graphics programmer using (or interested in using) DirectX, this book is more than worth its cost!

The same oppinion: not for beginners.