Rating: 
Summary: incredible amount of detail
Review: this is easily the biggest computer book i own, and i can already tell it's one of the best. i just got this a few days ago, and have already read 2 chapters and skimmed almost all the rest. all i can say is that i'm speechless. this is the book that graphics professionals and hobbyists have been wanting for years, it explains everything from the ground up in an easy to understand but thorough manner. i have at least 10 books on my shelf that were a total dissapointment because the author didn't really understand what they were teaching and the details were sorely lacking. this book is entirely different. so far the depth of information here looks to be more than almost any other book i have. i can't recommend this enough and can't wait until i have time to get back to reading it.
Rating:
Summary: Well worth the wait!
Review: This book has been in development for years and now I can see why. This is not another silly API book that regurgitates the same mile-long function references and likewarm 3D math primer. This is a book on how 3D graphics actually WORK, from plotting your first pixel to making a complete 3D game engine! If you actually want to UNDERSTAND 3d game development, this is the book for you. If you're using DirectX or OpenGL, this book will teach you how your API and hardware is actually doing the things it does, allowing you to take much better advantage of it and write optimal code. If you're coding for a new platform like GBA or the wireless/PDA platforms, you'll have to write your own 3D engine in software anyway, and this book tells you EXACTLY how. I'm already nearing the end of chapter 5 ("building a math engine") and I can't stop reading. I particularly can't wait for the chapter at the end on optimization, but there's so much cool stuff in between. Go see the table of contents for yourself! This is the book i've been waiting for since i started programminmg.
Rating:
Summary: Go for it !
Review: 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.
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: 3D Game Programming
Review: Want to create a cool 3D-based computer game? This book will help you become a great 3D game programmer. This book went to a great length to give you a solid knowledge on 3D game programming. The author of this book puts in great effort and many pages on explaining 3D programming clearly as possible. Because he wants reader to become the next generation professional 3D game programmer. I like his style of writing and its easy to follow and understand. I highly recommend this book on gaining knowledge on 3D game programming. Andre LaMothe is the pro in 3D game programming.
Rating: 
Summary: A Top-Notch reference!
Review: Well, let me explain my 3. The book is great and I love LaMothe's writing style. I'm also more a mathmatician than I am a programmer so I really enjoyed almost all of it (most 3D Books tell you how to program something without you having a clue what it's doing, very frustrating). All in all it's a really good book.
Though it lacks compared to TOTWGPG in that, it skips out completely on implementation in hardware, which was frustrating since finding a good source of cohearsing DirectX to do what you want is hard to come by, especially in this "Managed" day-and-age.
Anyway, in short, great for understanding the math for some beginner to advanced techniques, but definetely not the only one to have on your shelf if you actually plan to program anything.
Rating: 
Summary: so much - yet so missing
Review: This book could be improved by the following:
use devcpp for win lusers and include it on the book cd - it's free
make sure code works on gcc in linux
use sdl - then the code will work on linux and the other oses
- sdl is free - why use directdraw54 and directinput90abc? that wont work for linux or mac users.
assembly code should use nasm instead of vc - nasm is free
use blender for 3d models - free
whoaaa - mmx or sse...
where's the 3dnow? maybe the author is getting money from intel below the table but most people i know have amd rigs we want to know about 3dnow - why the intel loving? (update the book to include 3dnow)
With all of the above changes we would've had a completely stand alone book with fully working compiler, 3d tools, etc. That would've been awesome.
Rating:
Summary: One book to cover them all
Review: That's a great book! It teaches you how to program a 3D software engine from scratch. The book starts with a simple "hello, world" program and covers the needed 3D math, rendering, animation, physics and optimization. If you are interested in game development you should definitely get it.
Rating:
Summary: Very good books by LaMothe
Review: 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.
Rating:
Summary: Comprehensive
Review: 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.
|
