Rating: 
Summary: Try it before...
Review: I'm a software developer, working for a big company (big M).
There's only one author better than Andrè in this stuff (I mean trying to explain how a 3D engine works without accelerators) his names? Mr. Abrash the King(Zen of ASM..,Zen of Code opt,Black book).
Only one thing that explain how useful this book is:
Who drives the hardware manufacturer (ATI, NVIDIA) crafting their HW chips that all of ya use and loves?
The manifest difference between a Directx poor programmer and a "3D Innovator that knows how it happens" stands in this book so take it now, learn the basis and contribute to change the next Directx or OpenGL set of API's :D
Ciao
Rating:
Summary: The God of 3d programming books
Review: 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.
Rating:
Summary: Excellent and approachable 3D engine tutorial
Review: 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.
| 
