[.ca] Tricks of the 3D Game Programming Gurus-Advanced 3D ... (ISBN 0672318350)

From Amazon.com:
To be an ordinary programmer is one thing: You need only learn how to interact with the computer on its own terms, creating buttons and combo boxes that have no significance away from the screen. To be a game programmer--particularly one that writes games with environments that appear three-dimensional to their players--is something else entirely. Such work requires that the flat screen simulate the real world, complete with light, shading, texture, gravity, and momentum. It's all quite complicated. Tricks of the 3D Game Programming Gurus helps its readers make great progress in creating 3D worlds and the action that goes on in them. That this large, dense book manages to explain how to design and implement a 3D game while neither glossing over too many details nor swamping the reader with trivia is a credit to author André LaMothe. He opens by showing (and explaining) the C++ source code of a simple but full-fledged 3D spaceflight shooter game--a real boost to the reader's confidence. From there, he explains the complicated geometric concepts and mathematics that underlie realistic games (always with an eye toward software algorithms) and shows how to use the many APIs and libraries (including Microsoft DirectX 9.0) that make the world-builder's job easier. Make no mistake: Designing and building convincing games with 3D visuals and behaviors that convincingly approximate real-world physics is hard work. In this book, LaMothe helps you get it done and enjoy the process. --David Wall Topics covered: How to design and build 3D worlds and the goings-on within them. Aside from mathematics and geometry, this book focuses on wireframe models, shading, rendering, and animation. Microsoft DirectX 9.0 gets special attention.

Excellent and approachable 3D engine tutorial:
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.

The best game programming book available:
I read few reviews here in which some of the people said that Lamothe's C style of coding sucks and he explains in a lengthy and boring manner. Please...please...please...Haven't you read the back cover of the book ? Lamothe said that by reading this book, a NEWBIE in game programming can write a Quake II kind of engine. That means it is more concentrated on newbies. By Object oriented programming, a beginner may lose interest by feeling the complexity of OOP. Writing in C style will be simple for a newbie to understand. Lamothe also teaches us concepts in a funny way by which one can feel the nativeness. For all the newbies, this book is a must buy. For all the senior game programmers, who code in OOP can still buy the book for variety of concepts it deals with.

Read this book if you want to learn game programming:
I have read many game programming books, and I must say this is simply the best. It is well written and comes with a wealth of solid code samples ranging from small examples to entire games. Andre' begins with the basics of Windows and DirectX programming, then before tackling the more complex topics of 3D rendering he covers the Mathematics required to truly understand game and graphics programming. The sections on 3D math and advanced 3D rendering are what set this book apart from the crowd, by covering more than the normal superficial overview. These sections alone are worth buying the book.

Perfect Book - 3D Graphics from the Ground Up to the Sky!:
Excellent!!! I've bought a lot of graphics programming books lately...about three dozen! And all of Andre LaMothe's Books are superb. This book on 3D Graphics is an expansion of his first book on Windows Graphics Programming. It's worth every penny, and for beginners he teaches you from the ground up, starting with one pixel on the screen. The Demos are great, the source code is easy to understand. The explanations are laid out in a very great conversational quality. I haven't put this book on the shelf since I've got it, it's always open! I've only endorsed one book on the internet, and this is the one, because I think that it is so great! This book would be an excellent reference for programmers also! The accompanying CD is worth it's weight in gold, Andre LaMothe really knows what he is doing!

Go for it !:
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.