Customer Reviews

Tricks of the 3D Game Programming Gurus-Advanced 3D Graphics and Rasterization (Other Sams)

5 star:		(57)
4 star:		(6)
3 star:		(3)
2 star:		(3)
1 star:		(2)

 

 

I want to make it clear to all that are potentially buying this book. Tricks II is about SOFTWARE algorithms and rasterization. There is NO coverage of Direct3D, OpenGL, etc. If you're interested in learning about APIs then this is the wrong place. If you're interested in learning about HOW TO DO IT from plotting a pixel to Quake II technology then this book will show the way. I can say that there is nothing like this on the market, and probably never will be. The amount of time needed to illustrate multiple 3D engines, and technologies, build the demos, and try and make it fun, and engaging is simply too time consuming. I wrote this book for myself, when I was learning 3D graphics all I had was the BIBLE "Computer Graphics - Principles and Practice" which is fantastic, but lacks implementation, and practical examples. Thus, my goal for Tricks II was to re-create the algorithmic and mathematical vigor of Principles, but with a more grounded, and practical approach with real-time considerations. I personally guarantee you won't be dissapointed, the demos are very cool, and good starting points for a number of games types from; space, indoor, water, road, and fighting -- But, once again, if you want to learn boring APIs and not understand the fundamentals of 3D graphics, then don't look here! :)

Andre'

Simply put, this book is amazing. I'm a 3D game programmer myself, even written a couple books on the matter (*cough* Focus on 3D Terrain Programming *cough*). I've read just about every major book on 3D graphics and a heck of a lot of books on game programming, and I can safely say that this is THE best of both worlds. I've never seen a book this thorough before in my life. Andre, who I know from personal experiences as a great guy, really shows his incredible knowledge of 3D graphics, and even game programming in general. It's nice to be able to read through an explanation and think "wow, this guy definately knows his stuff inside and out".

Absolutely great work. I know it was a long time in the writing, but, from my point of view at least, it was very much worth it. Don't listen to the nay-sayers that throw this book off the mark due to it's lack of using Direct3D or OpenGL. This book teaches you what's most important about 3D graphics: THE THEORY! How are you supposed to program 3D games by solely knowing how a 3D API function changes a scene? You can't. You not only need to know how the function changes the scene, but WHY it works the way it does and, some times, how it can be improved.

If you're a beginner lost in a 3D void, this is definately the book for you. However, it's almost more important to note that if you're an intermediate programmer who has EVER wondered about the "why" behind 3D graphics, then this book is also definately for you. Just buy it.

As others have said, this book teaches you how to write a realtime software renderer. This is an amazing enough achievement--there is a LOT of information here. And unlike the SUPER MEGA DIRECT3D AWESOME PROGRAMMING sort of book that seems to come out every month, this is stuff that is useful over the long term, not just until the next API revision. There's no other current book I know of that teaches this--ever since 3d acceleration got on the scene every single book on game graphics programming seems to have been on how to use whichever API. The great things about Lamothe's book have been plentifully written about in other reviews on here, so I won't dwell on that much. Suffice to say, if you want to learn an API, don't bother with this. If you want to learn how 3D graphics actually work, this is the book you need.

I do have a few problems with this book, though. LaMothe's writing style can get gratingly casual, and he's not nearly as funny as he seems to think he is. I'm not asking for an ultra-dry computer science textbook here, but the constant cheesy humor does get kind of tiring. LaMothe's coding style is ugly and haphazard (largely a personal judgement, I realize) and he uses very little in the way of C++ features, even in places where they would make things a lot more natural (again, personal preference). Finally, he spends far too much time explaining his own APIs, information that would really have been better off on the included CD, saving valuable pages for more rendering knowledge.

So, overall, a wonderful and useful book, with a few rough spots. I hope there'll be a second edition.

Okay, maybe not the best book in the world. But it does do exactly what it says it is going to do, plus Andre Lamothe both knows what he is talking about, and presents all of the information in a logical and easy to understand way. A must have for all learning game programmers. After you read this book (which takes awhile) everything that you would need to know to write a full fledged 3d game is in your head. Long yes, but that is because the collosal amount of information in it. The CD contains source code for everything in the book. So not just do you have an explanation, but you have samples to play around with and learn from. Great book! But I would advise first reading his first book in the series, Tricks of the Windows Game Programming Gurus, and then just skip the first three chapters of the 3D game programing, that way you get the whole deal. I have read both books and have made several games using his information.

Another in what, a series spanning over a decade now. LaMothe brings up subject matter in a way others merely glean over. This time he takes what you learned from the previous book, Tricks of the Windows Game Programming Gurus, and gets into 16-bit color, real 3D issues and solutions, a large section on math and geometry derivations, model formats and loading issues, presentation, AI, sound and a host of other nuances that you'll run into during game design and implementation phases.

HOWEVER: I thought it would benefit readers to repeat an important aspect of this book.

This book is the SECOND book on this subject. The FIRST book; Tricks of the Windows Game Programming Gurus, contains the build up of the base library he uses and adds to. If you can't scan through the first chapter of this second book, you need to understand this. He makes it perfectly clear that this book will not break down the library he uses from the first book. The source is of course contained on the CD with this book, so you can do the lookup yourself. But if you are looking for the book to get started, get the first one. AFTER you've read the first one and have an intimate grasp of it, move on to this one. The techniques and subsequent additions he makes to the original library will be more than a bit confusing if you haven't read these books in sequence and don't understand what he's doing. If you've already done other reading on DirectX or made a simple DirectX window or fullscreen then you won't feel so lost. I believe this reiterates what the previous reviews stated. This is not a flights-of-fancy beginners book. That's the purpose of the first book.

This is the problem you will find with a lot of other "beginner's" books. Their first book is written and talks about the authors library which is already written. With LaMothe, he wrote them in order with the true beginner in mind.

You MUST have a very good understanding of C at the least, C++ would give you the best basis to read and implement his code. I say this because this engine is completely software driven and uses DirectX 7.0. It compiles fine with 9.0 because MS still includes the interfaces for DX 7.0. If you don't know what that means then you need the first book.

If you are expecting to have an engine that does what the latest commercial engines do, don't. The graphics pipeline he uses is software. But you will know more than enough about the basics of an entire 3D engine pipeline along with the peripheral engines; AI, Physics, Sound, Input, when you're done that you'll be ready to look at other available engines in a whole new light.

I'm not a fan of his writing style nor his sense of humor. I'm the guy who likes tech manuals. Once you get past the unneeded pages of his tangents and humorous anecdotes you will find some of the best information available on the foundations used in designing and implementing a workable 3D engine. If any of the information above, such as "pipeline" and "interfaces" doesn't makes sense, this book will overwhelm you from chapter 1. Get the first one. It's big, It's green, It's the HOW-TO of getting DirectX and Windows to work together to make a black DirectX window. Once you're there and understand how you got there, this book will take you into advanced subject matter.

I recommend this book highly if you've read the first. And even though the book title says Adv. 3D Graphics and Rasterization (the process of presenting a scene on the screen), LaMothe shows you the other things that go into a real game engine. This book does deal with advanced geometric mathematics, so have the relevant resources available when you get lost. He'll only hold your hand if you can stand on your own two feet in this department, it's not a math book.

In his latest book, "Tricks of the 3D Game Programming Gurus," Andr? LaMothe develops a 3D software engine by adding new functionally sequentially through each successive chapter. The book is a little over 1600 pages, comes with a companion CD and retails for $59.99.

Writing a graphics engine in software may not seem all that sophisticated, but it is an excellent way to approach computer graphics. By having to write specific functions that are typically abstracted by a platform specific API (i.e. DirectX), LaMothe focuses on the underlying theory and provides the reader a conceptual framework that is easily adapted to various targets as need arises.

While this book is the second volume in the Tricks series, having read the first book is not essential. To handle the 2D graphics, audio, and input, LaMothe starts off with the engine developed from the first book with DirectX 7 - and builds the 3D software engine on top of it (through the course of the subsequent chapters).

The first section introduces DirectX, the basic game structure, and the previous library's functional interface. In order to maximize time (and pages) building the new 3D engine, LaMothe abstracts the DirectX and Win32 code by encapsulating the computer interface to a set of three libraries to handle window construction, input, and audio. The book adequately describes the basic foundations necessary to use DirectX and Win32 without dwelling on many of the specifics. The main objective is getting to the 3D portion of the book and a "black box" approach is best for the platform specific wrapper code.

The second section begins with linear algebra and trigonometry. The math section spans over one hundred pages and forms the basis of the math library described in the subsequent chapter. Having most of the fundamental groundwork in place, LaMothe begins to develop the pipeline for the 3D engine. From the local to world transform to projection, the sub-steps necessary for rasterization are well detailed and described. In order to read external model data, several functions are developed to parse the output of the modeling tools included on the companion CD. By the end of the section, the engine is able to render in wire-frame.

After having the basic engine in place, the book really takes off. LaMothe starts the third section of the book adding critical enhancements: lighting, texture mapping, clipping, and a depth buffer. Starting with the mathematical background, each topic is thoroughly explored then the functional changes to the engine API are presented. LaMothe writes in a clear and sometimes too familiar fashion. The book reads as though LaMothe is speaking directly to you while transcribing his thoughts to the page.

In the final section of the book, LaMothe tackles several advanced graphics topics: perspective texture mapping, spatial partitioning, shadows, and animation. The visibility chapter is particularly strong with an in-depth look at Binary Space Partitions (BSP trees) and various other portal techniques. The engine code and examples are well commented and makes it easy to jump back and forth from the book to the source code.

The companion CD is as robust as the book. It contains a bevy of additional resources - nearly 600 MB including all the source code covered in the text (with pre-compiled executables), the book's appendices, twenty five articles from various authors on everything from Artificial Intelligence to Pentium optimization, source code to Quake, and trial versions of some helpful game development tools, like Sound Forge and Paint Shop Pro, and the DirectX 9 SDK. The modeling tools are a very nice touch and add to the completeness of the overall text.

Simply put, this is a thoroughly satisfying book. While LaMothe's approach in developing the engine is sound, understand that he makes design choices throughout the book to specifically make a fast software engine (i.e. no shaders, no complex light models, lookup tables, etc.). The theory behind his choice in approach is the valuable part of the book and the engine is just a practical demonstration. A reader looking to develop their own engine or understand the details behind the scenes when using an API like DirectX will truly appreciate the effort LaMothe has undertaken.

This book rocks.

It teaches you how to program a software 3D graphics engine from the ground up. Notice I said create a software graphics engine and not how to use hardware API to create an engine. This book doesn't cover the hardware 3D APIs, Direct 3D and Open GL. It shows how those libraries were created. With this knowledge learning any 3D API is greatly simplified because you have an idea of what is going on behind the senses. The math necessary for 3d graphics is introduced with a no nonsense approach which ignores theory and concentrates on application. Math covered is 2D, 3D Coordinate systems, Very basic Trigonometry, Vector operations, Matrix Operations, Introduction to Quaternion, and some basic calculus.
If you're not already at the college math level then you may need some supplementary material in this area, but this is not the book's fault it is simply that nature of 3D graphics. Bottom line if you want to work with 3D graphics you'll have to get a handle on the math and this book gives you a good guideline for which areas of math are important.

The optimization chapter is worth the price of the book alone, honestly. The author explains SSE, and shows how to use many tools which can track down the slow areas of your code. He explains how to use the Intel C++ compiler which integrates itself directly into the Visual C++ IDE. The compiler that generates the fastest code is Intel's compiler which makes sense considering they make the Chips!. If you already consider yourself really good with 3D graphics do yourself a favor and go to a bookstore and thumb through the optimization chapter.

A few words of warning however. If you don't consider yourself a very good C/C++ programmer then you will be lost. If you can not create a simple windows application using the Win32 API then this book is probably a little too advanced for you. (...) If you look these over and have a good idea of what is going on and want to learn more about 3d graphics then this is THE book.

Out of all the programming books I've read, Andre LaMothe is the best author. He is not lazy, and when it comes to something as sophisticated as 3d game programming, he takes about 1600 pages so that you can understand it all, inside and out.

Throughout the book, LaMothe takes you on the journey of creating a 3d engine. The engine is a software engine, meaning your 3d card won't help rasterize the graphics, which means the graphics will be slower and not look as nice. But by the end of the book, you will have learned so much from programming a software engine, that going on to Direct3D or OpenGL shouldn't seem to hard. Of course, you could stick with the software engine that you create by the end of this and use it to make full playable 3d games.

LaMothe goes through everything you need to create a 3d engine. Now that I have read the book, not only do I have confidence I could build a pretty sweet Direct3D engine, I feel I understand how 3d engines and graphics work much more in-depth. If you're not sure where to begin your study of 3d game programming, start here. As far as I'm concerned, this book is the god of 3d game programming books.

This book is pretty much one of a kind; there no other books out there that can demonstrate the creation of a basic software 3D engine while covering 3D theory in depth! Really, I would advise anyone and everyone against buying any general 3D programming book that only demonstrates the use of an API: You can learn that stuff from the SDK docs, folks!

Although the things you learn in this book will not be directly applicable to PC programming (there is absolutely no more reason to write a software 3D engine for the PC anymore regardless of what anyone thinks), this book will tremendously help your understanding of 3D graphics and make it a piece of cake to master any 3D API.

Of course, I can't end this review without complaining about something, even if it's not a huge issue: I really can't stand LaMothe's coding style. It's so ugly it just pisses me off, especially the naming conventions he uses for his functions. He himself says he uses C++ in his own projects, so would it really kill him to use at least a little overloading here and there to make his code a bit more readable? Also, many of the code optimizations he proposes are rather ridiculous. Bit shifts are NOT going to speed up your code, and the very idea of using all those globals gives me nightmares. =)

Regardless, since you are expected to already be a competent programmer in order to understand this book, you probably won't be infected by the style he adopts here, so the above is not much of an issue. If you want an in-depth introduction to computer graphics and are willing to take the time and effort to thoroughly learn this complex subject, I highly recommend this book.

This book is an excellent way to get started in 3d.It covers all u need to know to implement a software engine yourself.
This book covers z-buffering, BSP trees, lighting, texture mapping, alpha blending, 1/z buffering etc. and it is simple
enough for a newbie programmer to understand because the code is mostly in C.
I simply cant believe that LaMothe could cover all this topics in a single book.The demos are excellent.
This book is a must-buy if you are serious about game/graphics programming.