Special Effects Game Programming with DirectX w/CD

Mason McCuskey

1 My new favorite book, move over tricks!
This book covers an amazing amount of material with a fun, down-to-earth writing style.

I mostly referenced this book for specific effects as I needed them, each chapter is kind of like a stand alone tutorial, very easy to follow and actually implement in your own code.

You can make a 3d game with this, I did.

2 GOOD BOOK!
But!!!
alot of mistakes!
all the code is wrong!
you need to look at the examples on the cd to be able to run even the first program.
this is the ONLY disadvatage...
everything else is GREAT!!!
you should buy the book if you are intrested in RPG.
it explain preety good about almost all you need, except meshes...
but Jim Adams got another new book about meshes and skeletal animation.
buy both of them :)
enjoy

3 Another PrimaTech Blunder
Every book in the prima tech series, this one included, spends an unnecessary amount of pages on the basics that you learn when you first start programming. I knew all the basics that are talked about for 100s of pages in these prima tech books after reading my very first book on game programming, titled "Windows Game Programming For Dummies" by Andre LaMonthe. Prima Tech has been complained about by a huge percentage of people for not putting enough of what the book title suggests into thier books, while putting way too much about what their book title should imply that the readers already know. Those things include: Win32 API basics (such as making a window, menus, buttons, dialog boxes, and a half a dozen other things), introduction to COM architecture, introduction to DirectDraw, DirectSound, DirectInput, DirectPlay, DirectX Graphics, etc, etc, etc, etc, etc.... When someone like me wants to buy a book that focuses on Special Effects programming, why should I have to expect 500 pages of useless information that I learned 25 books ago, and expect only 300+ pages of actual content. And none, and I do mean NONE, of the prima tech books actual "content" goes beyond the classification of BASICS. Most basics can be figured out by the programmer, advanced topics, yeah the ones programmers actually buy the books for, are almost never covered.

However, the two best books by far in the Prima Tech series are "Multiplayer Game Programming" by Todd Baren and "Programming Role Playing Games with DirectX" by Jim Adams. If you combine what you learn in those two books, you will have enough knowledge to construct a Direct3D application, like an RPG, that has multiplayer support. Todd Baren's book even covers MMORPGs like EverQuest, Anarchy Online, Ultima Online, & Asheron's Call. MMORPGs are some, if not THE, most popular PC games on the market right now.

4 Not bad...........
This book is halfway decent. It reminds me a lot of back in the day programming little tricks in dos to make cool effects on the screen. Actually, it reminds me a lot of my high school computer science class when I already knew the language, so the teacher let me sit and make a graphics demo to teach the graphics portion of the class. I made a whole ton of demos of neat little tricks that were simple to do but had a good effect.

That is what this book is like. You get a few neat tricks, but the problem I have with this is the same as all the others: too much beginner garbage. On top of that, the content does not allow you as much room for expansion beyond what it gives you.

Bottom line:

It's a buy next to many of the other books out there. But it's still not near the top dog, Programming Role-Playing games with DIrectX by Jim Adams is the best one.

5 Too much fat and not enough detail
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.

6 Special Effects Game Programming with DirectX 8.0 Review
Excellent book. There is about 100 pages on beginning Direct3D. This section is clear and concise. It explains a lot of the flags that the DirectX SDK Help seems to miss. It also tells you good defaults to use to get it working. The code examples are great because they are straight and to the point. They don't use any wrappers (at least not the ones I've looked at). Also, the book uses D3DX in the samples, which was a plus for me, but that may be a matter of preference. The book content itself explains both D3DX & straight D3D ways of doing things, which is excellent. The downside is that the Direct3D material doesn't step through the examples. However, the example code was clear enough that this was acceptable. There is a lot on special effects, too, using the advanced features of Direct3D. This seems to me to be a good way of learning the features -- by having a purpose for them.

7 A Mamoth Project but more is Needed
WSU Virtual Worlds: Strong Introduction to GDI. The author provides specifications highlighting device context, creating a window, dialogs, pens, solid and hatched brushs, and gdi objects such as circle, line, rectangle, polygon, and arches. I liked the authors ability to provide simple concepts which could be immediately grasped.

Good Introduction to COM. I felt the introduction to COM Interfaces were good. However, more helpful information was needed. If each COM query interface was described for Direct Music, Direct Show, and Direct Graphics my overall understanding of how to control these devices would have been enhanced.

Adequate introduction to Direct Music but sketchy. In the book, Direct music was explained, but creating an application using Direct Music required study of the DirectX Sample SDK. Its is true that the author provided the high level descriptions for Direct Music, but I was not satisfied that he explained: direct audio, direct sound, loading sements, and character type conversion in great enough detail. However, he did explain the relationship between direct sound and direct audio in the book. I had enough information to implement Direct Music in my application, but not enough information to know all the special effects that could be done with Direct Music. In the Direct X Sample code there must be over ten special effects that can be create with direct sound.

Elementary introduction to Direct Show. A very short code snippet was provided for Direct Show. Direct Show filters provide media streams for a variety of data formats: mpg,mp2,wav,avi,wmv,..etc I was excited to implement Direct Show in my application. However, control of Direct Show was lacking, I need information about how to control the media COM interface, getting feedback on the media frame, and positioning to a specific media frame. For more detail on the subject, I returned to reading sample code provided by the DirectX samples.

More detail needs to be added for Direct Play. A simple diagram is provided showing the two topologys for network games. This is a deceptively simple diagram. I would have liked to actual have step by step instructions necessary to create direct play. A very helpful sample like two person tic-tac-toe would have been greatly appreciated. It seems like network games would be an area of strong interest, but the author largely ignored direct play.

Direct Draw is scattered throughout the book. Most programmer will never become 3D programmers. However, the bulk of developers writing games will be creating 2D games. The book does cover 2D effects in the second half of the book, so make sure to browse the complete book to reduce fustration. Most game developers I know spend the first few years programming 2D games before moving in to 3D. 3D game programming requires a broad range of tool knowledge. The author show how to convert a 3DS file into an XFile and load the xfile into the application; however, he does not show how to implement a skinned mesh. If you want animated xfile development time is required.

Good introduction to Matrix and Vector Mathematics. The author provides a good introduction to the basic of 3D math: points, segments, vectors/math, cross product, dot product, and matrice multiplication; along with a simple introduction of transformation matrices: translation, transformation, and rotation. A more rigorous explanation can be found in Computer Graphics Using Open GL (2nd Edition) by Francis S. Hill Jr The author provides step by step instructions on how to create your first direct3D object.

Carefully study flexible vertex format, CUSTOM_VERTEX, and vertex buffers. The Flexible vertex format is used to tell Direct3D how to pixel shade: a diffuse colored polygon, a material and normal polygon, and a texture mapped polygon. Its very important that the reader has a perfect understanding of FVF. The author does a good job explaining how custom_vertex structures can be streamed to a vertex buffer. Vertex buffers have been widely accepted in Opengl, but implementation in DirectX was very different for me.

Adequate introduction to lighting. I would have liked at least three samples for : directional, positional, and spot light. The ability to alter the materials, light properties, and environment would have been very helpful. The author provides all the directx api specifications and concepts necessary to create light, but needs to add more assembly of the apis so a stronger understand of how to apply lighting to the application can be achieved.

Excellent introduction to texture mapping and advance texture mapping. I felt the author did a very good job illustration and explaining texture mapping, texture coordinates, cube environment mapping, sphere environment mapping, and alpha blending.

Special Effects span the last half the book. Topics covered: clouds, fades,wipes,melts,crunches,3d rain,smoke ,fire,2d explosions,guns and projectiles,lens flare,3d water. Each of the effects has a brief introduction to the concept and the author has provided a generous set of code samples to illustrate each special effect. The author does not detail the programming apis necessary to create each effect, rather provides code samples to learn from. If the reader is a beginner developer plan on spending alittle time to discover how to program the special effect in your application.

8 Good idea, terrible result
Terrible book overall. If you ar a begginer, then run away because samples that do not even compile. If you an average then you should also skeep it because when you find code that compiles, it will not run (GPFs and such). If you an advanced programmer, then you would be upset that most of the book seems to be dealing with too basic of the stuff. As an example I tried to build water example. I spend half an hour first configuring project, so that it would compile, then running it under BounceChecker to discover where it GPFs, and finally getting it to run, just to see some garbage. If I find it on some going out of bussiness sale for 5$ I might buy it (it has some interesting concepts for water and fire), but never for a higher price.

9 LaMothe painted himself into the corner
Andr� is a great guy and had a huge and fully legitimate success with his two initial "Game Gurus..." (DOS-based and a Windows rerun) books. The all-inclusive format of those was perfect, because, well, because both books were self-contained, sort of. It's clear that based on that success, they (A. LaMothe in cahoots with his publisher) decided to treat us to a mighty series of something similar -- and it would be good and proper, except they should have changed the books' structure to a more fitting, suitable for a series one.

What I'm getting at is this: half of this book is water intended for a newbie -- and I don't mean a games programming newbie, I mean programming newbie. So it's good for a newbie, just as I thought it was appropriate in his first two "Guru..." books to have everything from C programming to graphics chewed on. But I already have at least two books of his that cover all this, and I feel no need to purchase another sheaf of 400 pages of identical introductory material every time I'm looking for something new game-wise.

So, there's clearly a conflict between the old, all-inclusive format (appropriate for a stand-alone book) and the new idea with the series of books, each dedicated to a different aspect of game programming. I think it'd be better if he factored out all the intro bs into a separate volume, and limited the rest of books to what the titles say the books are about. Of course they want more money, and thick books look like they should cost more, and so they pad every book with a re-run of literally the same stuff so as to keep the prices up.

I don't mean to be wholly negative: overall, it's a good book, but it's so obvious that they padded it up beyond what I feel is tolerable that, just to make a point as a consumer, I won't give it the top rating that the special-effects part _itself_ fully deserves.

10 About the bad reviews
actually it should be known that LaMothe REQUIRES that all books in the series include primers for beginners so that they wouldn't be left out (and so that they'd also be willing to buy the book and put money in his greedy little palms so he can buy and drive more 100K cars, instead of programming....hehe...j/k).

11 About the bad reviews
actually it should be known that LaMothe REQUIRES that all books in the series include primers for beginners so that they wouldn't be left out (and so that they'd also be willing to buy the book and put money in his greedy little palms so he can buy and drive more 100K cars, instead of programming....hehe...j/k).

12 Yet another DX for Dummies book in disguise.
Amazing...

First 400 pages are a waste of paper.
Special Effects Programming??? Please! Better name: Windows Programming for Dummies: Featuring an Introduction to DX8."

Not sure if an editor actually opened this text, because all 3D mathematics and formulas are wrong... The author or whoever responsible creates bogus values for all matrices by transposing the vectors and the matrices; doesn't speak well for the experience of the author.

I wish a "real" professional game developer would write a book over at Prima/Premier books. You know, someone who actually has experience with advanced topics and has actually published a real game. Judging from the web page for the book's editor, it looks like Mr. Lamothe hasn't quite moved past DX6 in 2D.

Bottom line: Waste of money, waste of time...

And lastly: Don't let marketing rename your book. If you're writing a DX8 for Dummies Book, call it as such. Also, don't write an "Advanced Neurosurgery" book and introduce a scalpel for 300 pages...

13 Incredible DirectX Coverage
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!

14 Good but too much chaff
I'm giving this book three stars because it's certainly better than most of the [junk] that litters the game programming section of your local superstore. I generally agree with the other reviewers.

That said, here's my rant--
Isn't it about time we got some game programming books that aren't trying to be a bible for an absolute beginner. This book is a good example of what could have been... it could have been a book about special effects. That's a nice well-defined subject, and it could have been a nice thin and concise book.

I'm no game programming god or anything but I understand the Win32 API enough that I don't need to be told what a message loop is every time I buy a programming book. The same goes for vector arithmetic, COM basics, and C++ fundamentals.

This book is about 900 pages long. If you took out all the chaff, you'd be left with about 450 pages of content that lives up to its title. Why not just gives us that? Could it be that by throwing all the beginner [junk] into every one of these things you get to charge more for them?

15 A book of the MUST HAVE section
That's amazing. Cool effects that can blow up your computer, and programmed by you! I really like it.

16 Great book; lots of stuff you won't find anywhere else!
I heartily agree with the other glowing reviews of this book. I just received it today, so I have lots of reading to do, but I have skimmed the entire book and there's definitely lots of stuff here that I haven't seen in any other book.

I really like the format. There's not much code in the book itself, but there's lots of example programs on the CD-ROM. He also provides practical exercises for the reader to enhance his understanding. The text itself provides lots of detailed information on the specific topic of discussion.

His explanation of quarternions really is top-notch. And his description of Direct3D is really the best I've seen. Most books I've seen don't offer much more than the DirectX documentation itself. This book explains the principles behind meshes, lighting, materials, etc, in a way that requires no prior knowledge.

This book is part of Andre LaMothe's "Game Development Series." I'll finish by saying that until now I have not been a fan of this series. All of the books I've seen to date in this series seem to have little useful content, providing little more than the DirectX documentation and some sample programs. This book, however, could not be more different. It is so much better, I'd really like to give it more than five stars. If, like me, you've been turned off from this series, don't let that stop you from buying this most excellent book!

I really can't wait to read this book in detail and work through the sample programs. Oh, and by the way, there seems to be lots of useful utilities on the CD-ROM.

17 This book made me want to write my FIRST review!
I've really just started reading this book, but I wanted to write a quick review so as to let others know what they're missing out.

The quality and layout of the writing is the best I've seen, especially for beginners I'd probably actually recommend this book over LaMothe's own books. Its better explained and more informitive (as well as being fast and enjoyable). Such as instead of saying "just set it to NULL you don't have to know what it does", McCuskey actually explains what "its" for and why you don't need it (I always liked to know, instead of being left clueless)

Its about 900pages of pure content, with little code to break your train of thought (its on the CD). And so far not one sentence is wasted, unlike LaMothe and his comments on what $100K car he drives or how he's some programming "god" by winning a college bet against his peers (what a braggart).

It deals with the latest version of DirectX and nVidia SDK. Its very exhaustive on many (if not all) aspects of special effects that you can think of creating. And an unexpected plus to me, was the section on incorporating an intro AVI movie into your game.

Don't just listen to me, hurry up and get this book to find out yourself!...
btw...am I the only one whose annoyed at that picture of LaMothe on the back cover of all the GD books, where does he think he's in the 'Matrix'?...he seems to take all the credit from rightfully deserving authors, and thats just wrong in my opinion.

Though I'm glad he started this series of books.

18 This book made me want to write my FIRST review!
I've really just started reading this book, but I wanted to write a quick review so as to let others know what they're missing out.

Though I'm glad he started this series of books.

19 This book made me want to write my FIRST review!
I've really just started reading this book, but I wanted to write a quick review so as to let others know what they're missing out.

Though I'm glad he started this series of books.

20 Mason hits one out of the park
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.

21 Great book.
This is the best book for learning the basics of DX AND it is great in its topic: Special Effects. It is 2 books on 1.

The main part of the books explain many special effects like 3d water, particle systems, fades, cartoon shaders using vertex shaders...

Here is a link to the book's table of contents:

Finishing: Great book for the beginner to DX and to the intermediate DX programmer to wants to learn about many cool special effects. This book is not that "newbie only" as the others in the "Game Development Series".

PS:Click at the link...

22 Looks like we have a winner here...
I've been reading through this book for the past few days now and have been pleasantly and repeatedly surprised at the quality and meaningfulness of the writing. Before getting into the style, let's go through what the book covers:

Part 1: Basics
Chapter 1 - Intro to Windows Programming
Chapter 2 - Win32 API Programming
Chapter 3 - DirectX
Chapter 4 - 3D Math
Chapter 5 - 3D Concepts
Chapter 6 - Intro to DirectGraphics
Chapter 7 - Lighting
Chapter 8 - Basic Texturing
Chapter 9 - Adv. Texturing
Chapter 10 - Vertex and Pixel Shaders

Part 2: 2D Effects
Chapter 11 - Fire
Chapter 12 - 2D Water
Chapter 13 - Image Feedback
Chapter 14 - Image Warping
Chapter 15 - Clouds
Chapter 16 - Blurs and Image Manip.
Chapter 17 - Fades, Wipes, Transitions...

Part 3: 3D Effects
Chapter 18 - Particle Systems: Rain, Smoke, Magic, etc
Chapter 19 - Adv. Particle Systems
Chapter 20 - Explosions
Chapter 21 - Guns and Projectiles
Chapter 22 - Lens Flares
Chapter 23 - 3D Water

Chapter 24 - Vertex and Pixel Shader Effects

The chapter listing doesn't do the topics justice, though. For example the Chapter on Explosions takes you through sprite animation, billboarding, explosion clusters, particles sytem code, shockwaves and then finishes out with a quick few pages on adding a skybox. The breadth and scope of this book is ambitious - and well met - to say the least.

The writing style? In short, you're treated like an intelligent person. McCuskey doesn't delve deeply into a lot of the topics or spend pages on end listing function parameters. Instead you get a box off to the side telling you where in the DirectX documentation to find more information or other sources (books, mags, websites) if you want or need to explore a topic more fully. Likewise, you're not going to find page after page of code listing, just the relevant part at the relevant time. Now that I think of it, the book spends very little real estate on code listings. And it flows much better for it.

The benefit from a book like this isn't being told how to program a special effect. The benefit, of course, is finding out how it's done in the first place so you don't spend weeks going down the wrong paths. The solutions seem solid and elegant to me but it'll be interesting to see if anyone finds fault with them.

There's not much else to say. It's a well executed book and I haven't found any fault with it. I acknowledge first reviews like these are generally regarded cynically, but I'm sure others will back me up once they receive their copy. Well done, Mason.