Rating: 
Summary: The demos alone blew my mind!
Review: Anyone who has this book knows what I am talking about. The demo programs included with this book do more with a software engine than any book on hardware 3D programming i've ever seen. The jet ski one in particular is so great. I turned it into a whole jet ski game! i am currently working on a fighting game using the awesome mech demo at the end of the book. whenever i get a new computer book I always start by going over the CD demos, and this is one of the few books i've ever really been excited about after just seeing the demos! Of course the book itself is a monster; there is so much info in this thing i am going to be busy for quite a long time. in other words, i got well more than my money's worth, and would recommend this to ANYONE who has an interest in games or graphics programming.
Rating: 
Summary: Huge but should have been written five years ago
Review: I have been a software rendering freak ever since I leaned to program, so don't take my review as the average opinion. I don't want to give myself too much credit but I think my comments are more useful to the really advanced grapics programmer.First I was impressed by the book's size, but just looking at the table of content I realized there's a lot of things in it that any programmer who even thinks about making a 3D game should already know. The other half of the book is stuffed with code listings that I find of little use while reading the theory. Maybe it's personal, and I'm saying this with the greatest respect, but I don't like the way Mr. LaMothe starts writing without "knowing where we'll end up" and the way he tries to make every math formula a "cool" magical spell. I'd liked to have seen it a bit more coherent too. Most chapters just add a bit of this and that to the previous chapter. That's of course fine for people who need to experiment a lot themselves to learn things, but I expected more of the so-called advanced 3D graphics and rasterization. Don't get me wrong it does cover some advanced tricks and it certainly makes you 'think 3D' but it's only the tip of the iceberg if you want to write a competent game. So is it a bad book? No, not at all. Maybe I sounded too harsh because of my personal dissapointment, but I would have loved it a lot more if I read it five years ago. For starters, don't hesitate and get this book! It has the fundamentals of nearly everything in 3D game programming that would otherwise take you years to learn. All in all I'm only giving it two stars though since I believe it is generally overhyped.
Rating:
Summary: The best game programming book available
Review: 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.
Rating:
Summary: The book of all 3d game programming books
Review: i have already finished this book after only a week of owning it and i cant believe how great it is. i thought id never be able to understand this 3d stuff but lamothe makes it cake! the examples were easy to follow and grasp and im already working on my first game using an engine im writing myself. its a shame that game developers out there keep these kinds of things to themselves and im glad someone like this lamothe guy came around and brought us up to speed on the 3d game programming world. this is a must buy for any person interested in making games.
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.
Rating:
Summary: Perfect Book - 3D Graphics from the Ground Up to the Sky!
Review: 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!
Rating:
Summary: Read this book if you want to learn game programming
Review: 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.
Rating: 
Summary: Excellent information, but not concise and not C++
Review: This is an excellent book on writing a complete 3D engine in software from the smallest drawable element, the pixel. It is by far the best book available to teach low level graphics programming, and to learn the concepts behind how libraries such as OpenGL and DirectX actually work. It has it all, from the mathematics to coding techniques to optimization. Unfortunately, the book is not without its faults. Some of the coding is just sloppy. For instance, Lamothe likes to use lots of global variables. Perhaps there is a slight performance increase with these optimizations, but I'm not sure if it's worth the time and effort of debugging code with lots of globals. This is especially true for people just learning the concepts. In my opinion, he should have left the optimization to the end of the book, after all the concepts had been taught. Another problem is the use of C. Lamothe argues that it's easier to teach in C and that C is faster than C++. Honestly, this is 2004, and with Pentium's running in the 3GHz range, I think the speed difference is virtually non-existant. Perhaps there is a greater base of programmers that know C, but with nearly all college Computer Science programs teaching C++ and object oriented programming, the coding style seems a bit dated. Using C++ features could have greatly improved the clarity of the code. The last problem is Lamothe's long-winded writing style. I understand that he's trying to make his book "fun" by including little anticdotes and jokes, but this 1700 page book could have been done in 1000 pages easily. He writes like people talk, and, for a technical book, that's not the best approach. Here's one example, a caption to a screenshot: "You might notice a bit of similarity to the ancient game Tail Gunner. Mike, if you're reading this, did you ever get that Tail Gunner in your living room working?" I wrote one paragraph about why this book is great, and three about why it sucks. That's not really fair; it is a wonderful book for REALLY LEARNING what's going on under the covers in OpenGL or DirectX. I only hope that the second edition comes back a bit neater, more consice, and with support for C++. It's a fantastic value and I highly recommend it.
Rating:
Summary: Yeh.. buy this gem.
Review: As long as you buying a book on game programming... This is the book to buy. If you can hold your own as a C or C++ programmer and want to learn games programming.. this is a gem. A big gem!
Rating:
Summary: Lamothe is a 2nd rate programmer
Review: if you want to get confused by a trillion optimizations in the parts where understanding is the most important, by all means get this book.
Lamothe is still stuck in the mid-70's C days. He claims C++ is "hard to teach in" because it is confusing. I think it is more confusing to him than to any modern programmer. Old C is by far more confusing in my opinion. This book is 1700 pages long - a big chunk of it is almost pure code dump, that could easily fit on a CD (and does). The old-fashioned programming style, combined with his optimizations down to the assembler level makes the code hard to understand. I believe it is time for Lamothe to enter the 21st century with his programming style, and get out of the 70's.
| 
