Customer Reviews

3D Game Programming with C++: Learn the Insider Secrets of Today's Professional Game Developers

5 star:		(3)
4 star:		(6)
3 star:		(3)
2 star:		(7)
1 star:		(26)

 

 

In case people think that all the negative reviews below are from confused novices: I have been programming games for a living for over ten years, and find this book mostly useless.

As other people have noted, about 60% of it is DirectX reference materials. Nice, but not what this book is supposed to be about. Besides, you can download most of them for free from Microsoft.

The coverage of Direct3D Immediate Mode is spotty. The author will go into some areas (texture mapping) in depth, and then blow off even more important areas (use of the DrawPrimitive() functions) with only a few superficial paragraphs. Even more frustrating, since there is no example code, you can't look at sample source to fill in the blanks in the text. Even an experienced 2D game programmer like myself is likely to come away from this with no better idea of how to write a D3D Immediate Mode program than they had coming in.

In some ways, the portions of the book dealing with Direct3D seem more concerned with generic 3D issues than with what can be done with D3D. While some of this information can be useful, there are other generic 3D books (such as Lamothe's "Black Art of 3D Game Programming") that do the same in far more depth.

Unfortunately, there really are no good D3D Immedate Mode books out to recommend (maybe when Lamothe FINALLY gets around to volume 2 of "Tricks of the Windows Game Programming Gurus"...). However, one recommendation I can give is to save yourself $40 and a lot of aggravation by avoiding this title.

This book is a fluffy re-write of the Microsoft SDK documentation - it is 800 pages long - 25 pages of index, 457 pages of DirectX reference (which can be found in the SDK docs), 135 pages of printed code (and I only counted where more than two pages in a row were nothing but code) - no comments, no actual use of the code (because most of it is DirectX lib source! ), two pages of intro by Andre LaMothe (how can you endorse this book? ) - leaving 171 pages for 40 bucks! Look somewhere else.

I hate criticizing another mans work. But this book disappointed me so much I can't keep my mouth shut. If you think this book is about 3D Game Programming, you are sadly mistaken. This book is about the DirectX API. Period. Of 773 useful pages (not counting the index), only the first 318 are about DirectX, the last 455 are appendices of which 432 pages are a regurgitation of the DirectX reference (which could have been placed on the CD in the interest of saving some trees).

The Game Developer magazine touts this book as having a "full source code game engine." The book, nor the CD, have any such animal.

This is a great DirectX book. If the title had been "DirectX - An Introduction and Reference", I would have given it 5 stars! But it isn't. It is called "3D Game Programming with C++." I thought it would teach me how to "program 3D games in C++." Yet the entire book does not have one complete program sample. How about a wire frame spinning cube, or a polygon shaded spinning cube, or a texture mapped spinning cube? Agggggh!

There is a forward by Andre LaMothe that does nothing but praise the books coverage of Direct3D. Of course! That is what the book is about! "John's latest book, 3D Programming with C++, is what every Direct3D programmer has been looking for." Mr. LaMothe does not say "... this is what every 3D game programmer is looking for", because that is not what the book is about, and that is what was so disappointing.

And finally, it amazes how a book on Game Programming (ergo Graphics) can have a complete absence of graphical examples to reinforce the text (I have seen this to often in graphics programming books).

If you want a book about the DirectX API, buy this one! If you want a book about 3D Game Programming With C++, look elsewhere.

The book that opened my eyes to 3D Programming, and a wonderfull book for the programmer without a 3D clue, is "Flights of Fantasy : Programming 3d Video Games in C++ by Christopher Lampton." Though this book is 10+ years old, out of print and certainly does not cover new technologies, it was my awakening into the world of 3D graphics (and it even has a complete flight simulator :) )

As I see it, this book ok, with some glaring flaws.

1) The Auther should have included some demos of any kind, even a spinning cube demo that as the book progressed went from a flat shaded cube to a fully texture mapped, and lighted (point light source, of course) cube. This is not the case and is a definate strike against the book, so if you are looking for demos, don't look here.

2) This book needs a library! If you have already bought the "Black Art of 3D Game Programming" and "Windows Programming for Dummies" (which any dummy should buy before even looking at another game programming book! as they are both by Andre Lamothe) then you should have all you need to write even a simple spinning cube demo. It's costly, but it's another strike against this book to have to buy OTHER BOOKS to make this one useful.

3) Half the book is a reference to DirectX! I would much rather have had a more "Lamothe" style layout to the book, where you start simple then progress into a game. As it is, the layout is simple and effective, but it is another strike against the book as it leads up to absolutely nothing, not even a demo to put everything together (which I stated before)

In conclusion don't buy this book as a sequel to anything, it is more of a reference and I am definately dissapointed at that, but all is not lost. It covers alot of theory and many things I have not seen in any other book! Buy it as a reference to DX with a little bit of theory included, otherwise stay away until you have a firm base in windows programming and simpler DX stuff.

There is nothing in this book about game programming. There's actually nothing in this book at all related to programming.

You get 2 source files, yep count 'em --> 2. One header file and one .cpp file that define a Direct 3D wrapper class.

This book does not have any examples--game or otherwise--in any of its sections. Also, less than half the book is even about "3D". All the rest is either about Direct Input or ripped straight from the help files that come with DirectX.

Just another typical book from Coriolis.

I am a pretty avid programmer and I wanted to learn Direct3d. But, all you will find in this book is the SDK copied. This book is not very good and I brought it back to Waldens the next day to get my money back.

I would recommend Tricks of the Windows Game Programming Gurus by Andre Lamothe. It is a million times better!

The single most apt word to describe this book is "sloppy".

You never end up with anything after reading this book -- you don't build anything of value, you don't have a starting point for anything worthwhile, and you'll have had to correct error after error in the listings. In his first example, he refers to the WNDCLASS structure as the WINDOWCLASS structure, fails to declare it in the code, uses an undeclared HWND in the next line, passes an "Instance" parameter rather than "hInstance" to a function, then declares the variable "DirectDraw7Ptr" before passing "DirectDraw7" to another function. Throughout the examples, he neglects to use the SUCCEEDED() and FAILED() macros provided by COM, then uses them extensively in his wrapper libraries. It looks like he wrote the book while learning these things himself.

De Goes proceeds to make a complete fool of himself in the sections on music and sound. When he covers sampled sounds, he indicates that many people use SoundForge, but does not mention CoolEdit -- the shareware version of which is included on the CD. Not exactly unforgivable, but when he covers MIDI, he blandly asserts that many people use Acid Pro for MIDI composition... which is interesting, since Acid Pro is a WAV-based program that does not work with MIDI data. Apparently, he has never heard of Cubase or Cakewalk. It is evident at almost every turn that De Goes knows precisely squat about sound production. Thankfully, he doesn't talk about it much, either.

To add injury to insult, he provides a "trial edition" of Caligari TrueSpace, stating that it is preferable because it exports files in the native DirectX format -- but unfortunately, the trial edition does not save or export files. In any format.

There is, of course, redeeming value. That redeeming value is difficult to find, but over the course of this book you *will* learn some useful things like what the five major components of a physics simulation are (but not how to implement them), how to translate and transform objects properly with vector operations (but not how to build objects in the first place), and how to implement a DirectInput user interface (but not how to make it do anything in your program). He waves some AI concepts around, implements nothing whatsoever, then stops writing anything at all and prints 438 pages of DirectX reference tables -- in an 800 page book. A previous reviewer's "more than half" was *not* an exaggeration.

It is possible that this book may be more useful if you have his preceding book, but somehow I doubt it. This is not to say the book is not worth READING. De Goes cuts through a lot of mathematical crap with his discussion of vectors and matrix operations, and glosses over a few important tidbits in some chapters that you'd be well served to catch in passing. But the book is most certainly not worth BUYING.

I purchased this book, because of the lack of decent game programming material that's been coming out lately. I was able to read the entire book (minus the DirectX reference) in about 30 minutes. This book is assuming that you already have a Direct3D application running that for some reason, you haven't figured out how to texture map or light. With the amount of knowledge and experience that this book is assuming, there is no point to reading it. Save you money and find better information online.

Overall I think it's a pretty good book, but not without its flaws. Specifically, no where in the book do you find a complete game or even a compilable program, either of which would have been very helpful for beginning 3D programmers.

On the good side, let me say I loved the book's attention to math, its coverage of several difficult (but important) topics, the source code it does include, and the way it makes DirectX easy to understand. Most books just introduce matrix math, vector equations, and formulas and then leave you to wonder what's really going on. But in this book the author takes the time to explain what matrices are (4 vectors aligned on 4 axes!), how they work, the basics of vector math, and the theory behind most equations the book uses.

The book also covers some hot topics like precise collision detection, 3D path finding, and 3D optimization techniques. In general the theory is covered well, with attention to the math, and usually sample code is included (except for path-finding, where it's all theory).

The source code the book does include is first-rate. One class wraps DirectSound and lets you play a 2d or 3d sound in three lines of code (just give it the name of a wave file and it will do the rest). Other code wraps DirectInput and DirectDraw. You also find code scattered throughout the tutorials.

The tutorials on DirectX are very easy to understand, and do a good job introducing the different parts of DirectX and showing you how to use them. They're strictly for beginners, though, as they don't cover advanced info like you would find in Inside DirectX. They refer you often to the appendixes, which are a topic all their own.

The appendixes contain references for DirectDraw, DirectSound, Direct3D, and DirectInput, and they consume about half the book. They are very dryly written, but the few entries I checked are easier to understand than the SDK and seem to include more information on how to actually use the functions.

Would I recommend the book? All in all, yes, but don't expect to find lots of source code or any programs that you can learn from, compile, and tinker with (except in the SDK). Also be warned that if you can't use a DirectX reference, then half the book will useless to you.

"What a great book" I thought to myself as looked at the table of contents. It covered everything from DDraw to DSound, but as I started reading the chapters I found myself thinking "Maybe I should have saved my money". There are many reasons for this...

1. The source code examples are all laid out, but the documentation is not clear, and there is no clear way to tie them all together. Its like being given a steering wheel, a seat, and gasoline, but nothing to use them with.

2. The author simply mimiced what the DirectX SDK has. In my opinion thi book turned out to be nothing more than a reference manual.

3. Now that I have been programming for a while, I have noticed that the little code in that book was somewhat inefficient.

As any programmer knows, one of the hardest parts of creating an interactive game (besides the rendering engine) is the main cycle that must tie together all of the sub-classes and functions. This book covered many sub-classes, that can easily be derived from the directX sdk or MSDN library, but completely ignored how to tie them all together. No helpful information was contained in this book except for the reference section.