Customer Reviews

Advanced 3D Game Programming With Directx 7.0

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

 

 

I'll preface this by saying that I'm an experienced game designer and programmer (nothing big on my resume). I bought this book for the Direct3D Immediate Mode information primarily with all the other good gaming nuggets secondary (though still important).

The first 138 pages cover Windows and DirectX basics (DirectDraw, DirectSound, DirectInput, etc). Being basic information, I skipped this.

The next 96 pages take you through the foundations of 3D math. I started here to refresh what I learned in other books and college and must admit that I was lost within a few pages. The author understands what formulas are used where, but he can't explain the concepts behind them or why they work the way they do. You're often told that's just how they work, but without a fundamental explanation it just doesn't click. I guess it's the difference between a friend teaching you to drive ("this is how it's done") and an instructor teaching you to drive ("this is why it's done this way"). In short, I had to skip this chapter. ("Cutting Edge 3D Game Programming with C++" does a good job of working through 3D concepts in a fashion that's understandable.)

Chapter 4 (Artificial Intelligence) goes from page 233-276, however the practical knowledge stops on page 255. After that, motivation for AI characters, Neural Networks and Genetic Algorithms are all touched on, though not in practical terms (and other than neural nets, no code). The first 8 pages of the chapter talk about how NOT to do AI, so in the end you end up with a 14 page discussion of path-finding through a set of rooms.

Pages 277-321 cover UDP Networking (Winsock), which I found odd since the title would imply DirectPlay (and lobbies). The author doesn't compare/contrast DirectPlay vs Winsock. Flipping through each page, I don't see anything that explains how best to implement a multiplayer game (like managing interaction for a 16-person action game), only the functions to do it.

Chapter 6 takes you to page 405 and covers the basics of Direct3D - getting your app up and running. Nothing new here, mostly a list of the functions and parameters (which is fine). If you're buying a book *just* to get into Direc3D Immediate Mode, I'd recommend Microsoft's Inside Direc3D which spends much more time and whose initialization code alone is worth the price of admission.

It's not until page 407 that you get into the meat of the book: advanced 3D programming (not using Direct3D) which covers forward/inverse kinematics, bezier curves, progressive meshes and radiosity. Bezier curves appear to be covered well, but progressive meshes are just talked about. The rest really don't play a part in game programming.

Chapter 8 (up to page 566) is called "Advanced Direct3D" though it really covers Direct3D beyond the initial setup and rendering and deals mainly with textures - filtering, MIP maps, multi-texturing, etc. (Again, this info is all in Inside Direct3D.)

The last 32 pages (Chapter 9) covers scene management (how to not render what you can't possibly see).

That's the book in a nutshell. The author says up front he's not a professional game programmer and is still in college (which is fine and not meant to knock him at all) and it's apparent in the disjointed and sketchy presentation. In the end, I would recommend buying "foundation books" (like those I mentioned) and if you still have a yen for more knowledge, this book may offer a few new nuggets.

It seems that the reviews for this book have been somewhat controversial, with people generally either loving or hating it. In light of that, I tried to read it with as open a mind as possible, and hopefully this review is objective.

The title of any book tends to create an expectation of what the book covers, so you would expect the focus of this book to be on advanced game programming techniques first, and on DirectX second. Okay, so how does it do in each area then?

To start on a positive note, when it comes to DirectX coverage, the book does a pretty good job. Having read several books covering DirectX, only a couple of which included Direct3D, this book holds up pretty well to the competition. It's not perfect; the non-Direct3D components are only covered briefly, but probably enough to get you up and running. The Direct3D coverage is decent, though, and easier to understand than what I've seen elsewhere. The texture mapping chapter was probably the most relevant of the entire book (though a little more depth on multitexturing applications and an explanation of how to generate the images used in environment mapping would have helped). The hole in the DirectX coverage comes in the omission of DirectPlay. Granted, there is a big chapter covering UDP instead, which is more widely used than DirectPlay anyway, but there should at least have been an explanation of why DirectPlay isn't used.

The coverage of advanced techniques is somewhat limited, primarily because a great deal of the book assumes you are a beginner. Given that the word "Advanced" appears in the title, a lot of beginners are going to be hesitant to pick this up. And yet, the first several chapters introduce Windows programming, DirectX, and 3D math, which anyone considering themselves ready for an advanced book should already understand. Normally, I wouldn't consider these beginner sections a bad thing, since they are fairly well written (although the 3D math section isn't as well presented as it could have been) and to the point; however, as you'll see in a moment, the space could have been better used.

When the book finally gets to more advanced topics, the coverage provided is somewhat spotty. Even though, as you can see from the TOC, many advanced topics are mentioned, only a handful of them provide enough depth of coverage or sample applications. Generally, the author's excuse for not providing complete coverage of a topic is a lack of space; if that's the case, and if this book really was intended to cover advanced game programming, he should have dropped the beginners sections and instead focused on advanced techniques that are being used in games.

One other thing I just couldn't understand about the book was the ordering. Several chapters are inserted between the DirectX introduction and the Direct3D chapter (and it's not like all the chapters in between are required to understand Direct3D, since they include the AI, networking, and physics chapters). Since you can read the chapters out of order, this is just a minor annoyance, but it doesn't make much sense.

So, in summary, the title of this book is misleading. People buying it for coverage of advanced topics are going to be disappointed, although there are a few nuggets to be had. On the other hand, it provides a great deal of information for beginners, including fairly complete coverage of DirectX, and better coverage of Direct3D than you'll find in many other books. Although it's not for absolute beginners, if you have some game programming experience and are ready to get into 3D, this may be worth picking up.

Mr. Perez, the author, is really only a "kid" in college which, unfortunately, shows through in his writing style; but I will be the first to say I was (am) extremely impressed with his knowledge on the subject of 3D game programming.

He covers all the bases: Windows API (briefly), C++ templates, Direct 3D API (of course!), exception handling (very briefly), game AI, texture manipulation, networking (actually, this is what Dan Royer contributed), the mathematics behind 3D programming, BSP trees, etc.

One of the reviews above (or below) stated this book is a waste of money because all the information contained within (I'm paraphrasing) is already "out there" on the net. Meaning no disrespect, but this is idiotic reasoning. Using that as a basis, no book in print today should be purchased by anyone ever. No, you should definitely buy this book if you want a handy, bound reference book that can get you started in nearly every aspect of current 3D game engine programming.

The main reason I did not give five stars to this review is because of his writing style, but please do not let that deter you from purchasing this book if you are interested in 3D game programming.

Also, he expects you to be knowledgeable in C++ programming.

While it's nice that Perez has his buddies come online and write supportive book reviews for him, you should really listen to the fleshed-out reviews, which generally don't seem to favor this book.

And with good reason: as another reviewer points out, all the stuff in this book can be found on the Internet. Mr. Perez does a generally horrible job of explaining concepts to the reader - he gloss-overviews almost every topic, showing incomplete and out-of-context chunks of code (which he doesn't even bother to walk through). Examples? The BSP explanation is laughable, being more incomplete than the free BSP FAQ. The book contains a full chapter on UDP messaging (the book is about DirectX, right?). More than half of the book is wasted cut-and-pasting information from the DirectX reference material and Charles Petzold's windows programming book. The AI chapter is ludicrous, barely touching on the topics which are grandiosely spelled-out in the table of contents. The author doesn't even implement A*!

The biggest question the buyer has to ask him/herself when deciding whether or not to purchase this book is, "what can I find in this book that can't be found elsewhere?" After all, isn't that the reason to buy a programming book? The answer, unfortunately, is "nothing".

The "advanced" part of the title seems to reflect the expectation that you know C++ or at least a lot about how programming works. If you have that under your belt, this book takes you through a wide variety of topics involved in game programming, including a very good chapter on the mathematics involved in 3d graphics programming. This is the chapter that I've found lacking in so many other books, since my advanced math skills (especially with matrices!) aren't all that strong, but when someone explains how to do something clearly, I can usually follow along. Yes, you probably need to have taken trigonometry at one point, but this book gives a good refresher in that area.

The CD-ROM comes packed with source code to different popular 3d games (like Quake and Doom), and with a 20,000 line example game that demonstrates most of the techniques that appear in the book, so there's a lot to work from in this package.

However, you need to have some idea of what you're doing, both in terms of game concept design and programming, in order to get the most out of it.

The fact the book is written by a college student is a plus to me: the style may not always be perfect, but it's written at a level that other college students can understand.

I was looking forward to this book, as I thought Adrian's previous work was quite good and his willingness to share knowledge commendable. I had confidence that he would deliver one of the better game programming books around, so I put the book on pre-order.

Now that I've had it a couple of days, I feel quite satisfied with my purchase. The book covered exactly what it said it would, it was a little dissapointing that CSG and Physics (apart from some basic stuff) got dropped on the way to getting the book published, but what is left in the book more than makes up for it, in my opinion.

I don't know of any other books on the market about DirectX at the moment, that would allow a moderately experienced C++ developer to create a networked, multiplayer game engine with visibility algorithms like BSP Trees or Portals and some bells and whistles likes Bezier Curves, fancy texturing, etc. Other DX books I have purchased have turned out to be either too simple or just a printed copy of the DX Help Files. This book is much more than that.

Part of the reason that I feel happy with my purchase of the book is that the author intends to add to the code base that came on the CD and become involved with people who intend to improve the existing code. I am sure this book is going to remain in a prominent place on my desk for many months.

4 stars - No Physics or CSG are the only negatives, in my opinion. Of course, you wish every technical book could be longer, but you're only allowed so much bang for your buck. I'd have no problem putting the next book on pre-order also.

This book in my opinion is the best Direct3D programming book on the market. It starts off making a very nice win32 framework. Once thats out of the way it gives you class wrappers for DInput, Ddraw, and DSound. Next it hits 3D math, and provides nice object oriented data types representing the 3D primitives we use in 3D programming. Next is a good intro to AI programming and networking. Finally in chap. 6 we initialize D3D and make a custom model format. Chapter 7 and 8 provide a well detailed explanation of 3D algorithms and texture mapping. Chapter 9 explains portal systems very well. The main thing i liked about this book was the object oriented approach. It makes it very easy to modify the framework the author gives. Also the portal chapter was very helpful, and the BSP class and explanation was very informative. I highly recommend this book.

Granted, that takes a while... but it is worth it. This is basically a book that seems to cater to me exactly: I'm a programmer with a great deal of experience in C/C++, but I've never once tried to do DirectX. As such, I sat down this morning and by the afternoon I had read the first half of the book, and I must say that I am impressed.

I've tried to jump into DirectX before, but no book could explain the theories as well as this one... pared up with the DirectX help files from the microsoft web site, I was able to finally understand what on earth is going on with modern graphical programming. =)

The book does use wrappers, like a great deal of other books, but unlike some other books I've seen it shows you the theory behind the wrappers by slowly creating them over the length of the book... basically, making the wrapper the "tutorial example". Perhaps having a game as the continuative example would be better for some people, but I found the use of the wrapper as the example to be refreshing... perhaps I've been programming in the non-3D world too long though. =)

So, if you're in the same position as I am, where you have a lot of programming experience but until now was too afraid to try DirectX, try out this book. It seems good to me. =) Just be sure to have the Microsoft DirectX SDK instruction web site handy in case you have additional questions (I'd reccomend that no matter what book you're using though).

-Vendal Thornheart

I thought this was a decent introduction to using DirectX/Direct3D programming. I come primarily from an OpenGL under Unix background, and I've been slogging through Direct3D books in an effort to bend my OpenGL-centric brain around Direct3D.

One of the things I like about this book is that the authors skip a fair amount of minutia that the beginning DirectX-er doesn't need to know right away. I don't really care what the 8-bazillion different things the Direct3d enum caps callback can enumerate, and if I just want to draw triangles on the screen with a perspective projection, I shouldn't have to. I thought the DirectX intro chapters (not being a Windows jock) were quite well done.

Coverage of the math topics is a bit sketchy - you'd better have at least a passing familiarity with linear algebra and matrix manipulation to get something out of these chapters. If you're the kind of person who can really throw caution to the wind and accept a stated rotation matrix as it's printed, this should be OK, but I can't say you'll walk away with a good grounding in the fundamentals. If you know your stuff cold, you can probably skip the math chapter. Same with the AI and networking chapters - nice overviews, not a lot of in-depth explanations, and probably not a lot of relevance if you're not using neural nets or UDP. (DirectPlay, anyone?) I also would have put these chapters after the ones on Direct3D, not in the middle of the book. (Minor gripe.)

The following chapters act as a nice intro to Direct3D with some coverage of topics like environment mapping and other features seeing recent hardware support. The book is pretty up-to-date in these matters, talking about GeForce (still pretty new) and other chips.

I would have liked some discussion of the D3DX library from Microsoft - it encapsulates much of the grunt work Perez performs with his wrapper classes. If this book touted itself as more of a DirectX *7* book, I'd be a tad disappointed.

In short, one of the better DirectX/Direct3D books currently out there. Probably works best in conjunction with Inside Direct3D for the extra bits Perez and Royer (rightfully, in my opinion) skip.

This book is very easy to read. If concepts such as networking, BSPTrees, and AI are alittle fuzzy, this book should make it very clear. It only gets 4 stars because I felt the book to be slightly incomplete towards the end.