Please use and bookmark only this resource from now!
Send News
Added 11 Oct 04 Updated Today
Publisher Sams
Publication Date 2003-06-02
Paperback - 1728 Pages
ISBN 0672318350
Today is the greatest time in history to be in the game business. We now have the technology to create games that look real! Sony’s Playstation II, XBOX, and Game Cube are cool! But, all this technology isn’t easy or trivial to understand - it takes really hard work and lots of Red Bull. The difficulty level of game programming has definitely been cranked up these days in relation to the skill set needed to make games. Andre LaMothe’s follow-up book to Tricks of the Windows Game Programming Gurus is the one to read for the latest in 3D game programming. When readers are finished with Tricks of the 3D Game Programming Gurus-Advanced 3D Graphics and Rasterization, they will be able to create a full 3D texture-mapped, lit video game for the PC with a software rasterizer they can write themselves. Moreover, they will understand the underlying principles of 3D graphics and be able to better understand and utilize 3D hardware today and in the future.
André LaMothe has been involved in the computing industry and technology for more than a quarter century. He holds degrees in mathematics, computer science, and electrical engineering, and is one of the rare individuals that actually did work at NASA at the age of 20 doing research. His early teens and twenties were filled with consulting for numerous Silicon Valley companies, where he learned the realities of running a business and worked on his multidisciplinary background in fields such as telecommunications, virtual reality, robotics, compiler design, 3D engines, artificial intelligence, and other areas of computing and engineering.
His company Xtreme Games LLC was one of the first and last true "indie" publishers with a soul. Later he founded the Xtreme Games Developer Conference (XGDC) to give game developers a low-cost alternative to the GDC. Lately he has been working on a number of projects, including eGamezone Networks, an online distribution system for games that’s fair, fun, and has zero ads. Last but not least, he founded a new company, Nurve Networks LLC, to create handheld video game systems for value-minded consumers and hobbyists alike. Finally, he is the series editor for the world’s largest game development series.
On a personal level, he likes everything extreme, from weightlifting, motorcycles, jet skis, and hotrods to "railing" on his blades. He has even trained extensively with the Shamrock Submission Fighting Team under the tutelage of Crazy Bob Cook, Frank Shamrock, and Javier Mendez. You probably don’t want to get in an argument with him over DirectX or OpenGL - right or wrong, he will probably make you say uncle!
That this large, dense book manages to explain how to design and implement a 3-D 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 3-D 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 3-D visuals and behaviours 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 3-D 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. --Robert Lawton, Amazon.com
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.
Today is the greatest time in history to be in the game business. We now have the technology to create games that look real! Sony’s Playstation II, XBOX, and Game Cube are cool! But, all this technology isn’t easy or trivial to understand - it takes really hard work and lots of Red Bull. The difficulty level of game programming has definitely been cranked up these days in relation to the skill set needed to make games. Andre LaMothe’s follow-up book to Tricks of the Windows Game Programming Gurus is the one to read for the latest in 3D game programming. When readers are finished with Tricks of the 3D Game Programming Gurus-Advanced 3D Graphics and Rasterization, they will be able to create a full 3D texture-mapped, lit video game for the PC with a software rasterizer they can write themselves. Moreover, they will understand the underlying principles of 3D graphics and be able to better understand and utilize 3D hardware today and in the future.
Details;){kind=link}
New from 72.66 $
Used from 4.00 $
For all of you authors: We need more books like this. All of the rest of the books out there are hardware accelerate OpenGL and DirectX oriented. That’s all fine and dandy, but what about those of us who want to know what goes on under the hood? This book is great. It shows exactly was is needed for software rendering without OpenGL.
This book provides excellent information for anyone who is looking to understand 3D game programming built from the ground up. It does not focus on coding styles and practices. Instead, it takes the reader step-by-step through the process of creating a 3D game engine and explains the mathematics and optimization techniques behind each system. If you’ve ever wondered how to make a 3D game from scratch, this book will teach you. Note that this book expands on code from LaMothe’s "Tricks of the Windows Game Programming Gurus", which covers similar material in 2D.
Andre’ LaMothe is a pretty big name in the game-development education market. I feel, however, this is mostly due to the fact that his stuff allows "cook-book" programmers to just rip the code right out of the book and use it for their own purposes, rather than just lay out the theory and allow the programmer to do what he or she is supposed to be doing: programming their engine and solving problems.
It begins with a pretty fair introduction to REALLY basic mathematics (high-school pre-calculus level stuff), and then follows it with a section on how to build a math library. The problem with sticking in a math section such as this into a book, is that there are really no supplementary problems for the reader to figure out on her/his own. It just lays out the tools without giving the reader a chance to use them on their own (later in the book he shows how to use the math to derive things, but, again, the reader isn’t using his/her mind much...just being handed the algorithms on a $40 platter).
Then, the book goes into 3D concepts, describes various graphics algorithms, shows implementations, and then eventually, by the end of the book, LaMothe has written a cheap, Quake-style renderer which the user can then, presumably, use to build a game on top of. Or the more interested reader can even try to learn how everything is put together from the source. There’s one problem here:
If you’re looking to learn from example, then this book isn’t a very good one. John Carmack has released his sources for Quake, Quake 2, and Quake 3, and are truly professional game engines (the best in the industry, according to some). If you’re not willing to solve problems yourself and want to study somebody else’s work, then just go download the Quake sources...they’re free.
I probably sound overly harsh on this book, but perhaps it’s due to the fact that I’m the kind of person who likes to be given theory (even sometimes I’ll figure it out on my own) and be left to come up with my own, personalized code. Now, this book allows for that, but it does spend a good deal of pages on implementation, flat jokes, and massive code-dumps.
Speaking of flat-jokes, LaMothe’s writing style seems rather bloated with unnecessary colloquialism. It takes quite a few paragraphs to wade through his egotism and "cool" talk before you get to the meat.
In short: If you’re a newbie game developer and want a "quick-and-easy" introduction to software rendering (everybody should start with a sw renderer -- or at least understanding 3D graphics theory), then by all means, buy this book. It’s useful.
However, if math is one of your best friends, and you like solving problems on your own and implementing things your way, then I suggest just buying a 3D graphics textbook (Alan Watt’s is nice) and writing your own real-time software renderer (or even a realistic ray-tracer).
writer talk about too much basic knowledges which are used for 3d game programming , but most of them like knowledge of math and windows programming we can find in other books even in the course we studied long long ago.
wish writer take the 3d as the point and talk more about the newest technolegies arised this years.
I’m not going to spend a lot of time identifying and classifying each part of the book, because that’s been done by others and doesn’t really reflect the book as a whole.
I have a "good working knowledge" of C and studied 3D graphics at a basic level at University in the ’80s. I’m a good scripter, was once a pretty good assembly language programmer, and a C hacker.
The first thing that sruck me about the book was the size - there is a lot of content. Granted, a lot of it is code but by no means all of it and for a subject of this nature code is really one of the best ways to force someone to read and take note of a particular section. All the code is backed up with good textual walkthrough’s in any case.
I completely disagree with a previous reviewer who said that the CD was only worth 5 minutes. If you want a short-cut API-specific manual and take an ’I wanna make shiny things’ attitude, you probably won’t get a lot out of this book. Don’t buy a tin of pears and then review them in ’Apples weekly’!
If you want to *really understand* the inner workings of 3D chipsets, APIs such as DirectX and OpenGL then this book is certainly for you.
I personally only had two small problems - neither of which can be described as shortcomings on Andre’s part. The first is that my basic mathematical ability isn’t really up to following the detail of the chapter on mathematics. Andre is obviously well versed in math and uses it freely in this chapter. That said, he does recommend people get supplementary books (and lists a couple) if they have trouble following the math. The second thing I found was that the code wouldn’t compile cleanly by default using Microsoft Visual C++ 2005 (it was written using Visual C++ version 6 I believe). I mailed him, and got a VERY quick reply offering help. By this time however, I’d pretty much figured out the problems for myself (mainly due to Microsoft changes to the compiler) and fortunately didn’t have to press him for any answers.
Andre’s writing style is chatty and informal, which I personally like, yet packed full of really good and useful information. Perhaps sometimes he assumes that the text is easier to follow than it is, but frankly the nature of this book is such that complexity is simply unavoidable.
If you don’t like this book then in my opinion you really haven’t understood what it is written for, and thus don’t really qualify to judge it. It gives you in-depth knowledge about what’s going on INSIDE the likes of DirectX and OpenGL, not just how to use them. This is a subtle difference to a pure API guide.
In short, thanks to Andre for writing the book, and considering the scope of the material covered and the amount of work involved I think he’s done a cracking job.
These days it’s all too easy to just use APIs without thinking about what’s going on behind the scenes. I’d recommend it to anyone who is willing to put in the mental effort to really understand it. This is a seriously good publication.
I'm not going to spend a lot of time identifying and classifying each part of the book, because that's been done by others and doesn't really reflect the book as a whole.
I have a "good working knowledge" of C and studied 3D graphics at a basic level at University in the '80s. I'm a good scripter, was once a pretty good assembly language programmer, and a C hacker.
The first thing that sruck me about the book was the size - there is a lot of content. Granted, a lot of it is code but by no means all of it and for a subject of this nature code is really one of the best ways to force someone to read and take note of a particular section. All the code is backed up with good textual walkthrough's in any case.
I completely disagree with a previous reviewer who said that the CD was only worth 5 minutes. If you want a short-cut API-specific manual and take an 'I wanna make shiny things' attitude, you probably won't get a lot out of this book. Don't buy a tin of pears and then review them in 'Apples weekly'!
If you want to *really understand* the inner workings of 3D chipsets, APIs such as DirectX and OpenGL then this book is certainly for you.
I personally only had two small problems - neither of which can be described as shortcomings on Andre's part. The first is that my basic mathematical ability isn't really up to following the detail of the chapter on mathematics. Andre is obviously well versed in math and uses it freely in this chapter. That said, he does recommend people get supplementary books (and lists a couple) if they have trouble following the math. The second thing I found was that the code wouldn't compile cleanly by default using Microsoft Visual C++ 2005 (it was written using Visual C++ version 6 I believe). I mailed him, and got a VERY quick reply offering help. By this time however, I'd pretty much figured out the problems for myself (mainly due to Microsoft changes to the compiler) and fortunately didn't have to press him for any answers.
Andre's writing style is chatty and informal, which I personally like, yet packed full of really good and useful information. Perhaps sometimes he assumes that the text is easier to follow than it is, but frankly the nature of this book is such that complexity is simply unavoidable.
If you don't like this book then in my opinion you really haven't understood what it is written for, and thus don't really qualify to judge it. It gives you in-depth knowledge about what's going on INSIDE the likes of DirectX and OpenGL, not just how to use them. This is a subtle difference to a pure API guide.
In short, thanks to Andre for writing the book, and considering the scope of the material covered and the amount of work involved I think he's done a cracking job.
These days it's all too easy to just use APIs without thinking about what's going on behind the scenes. I'd recommend it to anyone who is willing to put in the mental effort to really understand it. This is a seriously good publication.
I'm not going to spend a lot of time identifying and classifying each part of the book, because that's been done by others and doesn't really reflect the book as a whole.
I have a "good working knowledge" of C and studied 3D graphics at a basic level at University in the '80s. I'm a good scripter, was once a pretty good assembly language programmer, and a C hacker.
The first thing that sruck me about the book was the size - there is a lot of content. Granted, a lot of it is code but by no means all of it and for a subject of this nature code is really one of the best ways to force someone to read and take note of a particular section. All the code is backed up with good textual walkthrough's in any case.
I completely disagree with a previous reviewer who said that the CD was only worth 5 minutes. If you want a short-cut API-specific manual and take an 'I wanna make shiny things' attitude, you probably won't get a lot out of this book. Don't buy a tin of pears and then review them in 'Apples weekly'!
If you want to *really understand* the inner workings of 3D chipsets, APIs such as DirectX and OpenGL then this book is certainly for you.
I personally only had two small problems - neither of which can be described as shortcomings on Andre's part. The first is that my basic mathematical ability isn't really up to following the detail of the chapter on mathematics. Andre is obviously well versed in math and uses it freely in this chapter. That said, he does recommend people get supplementary books (and lists a couple) if they have trouble following the math. The second thing I found was that the code wouldn't compile cleanly by default using Microsoft Visual C++ 2005 (it was written using Visual C++ version 6 I believe). I mailed him, and got a VERY quick reply offering help. By this time however, I'd pretty much figured out the problems for myself (mainly due to Microsoft changes to the compiler) and fortunately didn't have to press him for any answers.
Andre's writing style is chatty and informal, which I personally like, yet packed full of really good and useful information. Perhaps sometimes he assumes that the text is easier to follow than it is, but frankly the nature of this book is such that complexity is simply unavoidable.
If you don't like this book then in my opinion you really haven't understood what it is written for, and thus don't really qualify to judge it. It gives you in-depth knowledge about what's going on INSIDE the likes of DirectX and OpenGL, not just how to use them. This is a subtle difference to a pure API guide.
In short, thanks to Andre for writing the book, and considering the scope of the material covered and the amount of work involved I think he's done a cracking job.
These days it's all too easy to just use APIs without thinking about what's going on behind the scenes. I'd recommend it to anyone who is willing to put in the mental effort to really understand it. This is a seriously good publication.
I have to admit first, I was never a big fan of Andre LaMothe. This was because I managed to buy a copy of Tricks of the Windows Gurus that was a faulty print, covering DirectX4. However, there never was a DirectX4.. so, I was never again willing to buy his books..
Now, this book is really worth purchasing used, if you get a good deal on it, I highly recommend it. Even though Software rendering is pretty much a dead art these days, it is worth knowing the theory behind it. Every graphics programmer should have a good working knowledge of how to do software renderers.
Also, with the advent of multi-core CPUs, it is possible to distribute the load of the rasterizing on the cores. I think that is a very exciting idea to explore, and it would mean you no longer had to rely on the graphics cards manufacturers bad drivers, you could write your own drivers ;-) Of course, not everyone yet has multi-core CPUs.
Another interesting tricks you can try are hybrid tracers, using Raytracing, software and combine it with OpenGL to utilize the fast GPU’s ability to filter textures. Very exciting stuff.
This book is really good I think, and Andre LaMothe has presented the stuff fairly well, however I had to port the library to SDL as I don’t use Windows. Also, there are some errors in the book. Amazingly the demos ran on Wine, which was pretty cool if you ask me.
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.
This book rocks for sure, anyway, i’ve to warn about some odd things that may bother you as they bothered me.
I think 70% of the printed-code isn’t useful at all, some snippets would be good enough to express the concept, for more code there is the companion CD but, anyway, you can always skip those code-filled pages on your own.
Explanations are really well organized, but you need a solid background in order to follow the book completely, some concepts need experiments on-your-own rather than running-a-demo: for example, the "Perfect Perspective Correct" algorithm is well explained, but the demos "as is" doesn’t give you the chance to see the really perfect mapping at all: just move close to the objects and you’ll see bad textured polygons here and there, BUT those are demos, not full-games.
There are some math errors here and there but the most hard-to-find one is surely about this texture mapping stuff: you can crash the demos too while getting close to some of the objects with perfect texture mapping activated and this is due to wrong FIXED_POINT math used for making it running faster: if you already own the book, at page 1230 (fig. 12.22) you are going to line up the fixed points, this is correct, however shifting this way you are losing precision on the leftmost bits causing math overflows and wrong calculations (from a 10.22 to a 4.28 you are throwing away "pag. 1228, paragraph 1"’s efforts ;).
And note, there is NO 4.22 fixed-point format, Zi is a 4.28 one, fig. 12.22 is correct but pag. 1228/1229 states wrong, while pag. 1230 states at the last paragraph is correct again.
Personally, i think even these errors alone (chapter 12) would worth an errata, because some new-comers couldn’t figure out what’s wrong, but let me say this book is the most complete work i’ve ever seen on software rasterization: if you are serious about 3d graphics, buy it!
Like a reviwer Riccardo Audano already said, this is a software rendering engine. You can learn a lot from this book, but you can’t become a great 3D game programmer, like some other reviewer said. If you want to become a great 3D programmer, like the guys from Cro Team, who had a presentation on my computer graphics class in college (one of the benefits from living in Zagreb), you have to learn how to create hardware rendering engine. All in all, in comparison to other books on the market this one is OK, and I recommend it to beginner to intermediate level. The price of 60$ is too much, however. Luckily, Amazon gives 30% discount.
I have read this book cover to cover and I find it to be LaMothe’s best work. The demos alone are amazing, pure software, but yet run in real time. I recommend this book to anyone that wants to learn the math behind writing 3D engines and anyone that want’s to learn from an expert coder of 3D engines the tricks of the trade to make 3D engines without the use of acceleration hardware. Additionally, whomever posted the "nowhere" post is obviously a jealous programmer or competing author. Many of the reviewers have posted their emails, I suggest that anyone that wants to ask other reviewers simply email the people. I hate people that waste time putting up completely useless and obviously vidictive posts without any tangible points to make other than their own obvious attempts at slandering the author.
This book rocks, if you don’t think so, pick up a copy at the local bookstore and read it there. Also, there are a number of excerpts here that you can review as well.
The major majority of the 5 star reviews on this book appear to all be written by people who have only reviewed only this one book on Amazon.com.
This to me makes it abundently clear that the author, of whom I happen to have read books from before, is clearly getting his "buddies" to write 5 star reviews so he can cash in on what is obviously a thrown together book.
This sort of behavior of "false" reviews shows poor ethics and business practices and I am now honestly considering to never buy anything with the name "LaMothe" on it ever again.
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.
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.
This is a must have for anyone wanting to learn 3D Game Programming with DirectX. However, as with all great books you need to do some work - and I would advise that you read the first "Tricks..." book first. When I started using this book it was hard going - I have no experience in Game Programming - but when I went through the first book and followed each example at a steady pace, including trying out the code I found the second book became easier when I returned to it.
This book is well written, and LaMothe clearly wants you to learn the inner concepts of Game Programming rather than just giving you a 3D engine. He clearly enjoys the subject - sometimes going over the top - but once you learn to find the important bits, you will be surprised how much you have learn’t from him.
In many cases he gives you 2 or more ways of doing things - for example using 8 or 16 bit, manual or matrix calculations and Euler or UVN Camera. My advice is stick to one method to the end of the book and then come back and update with the alternative.
A great book...After reading it you can probably develop the next Quake or Half-Life engine easily...
This is a must have for anyone wanting to learn 3D Game Programming with DirectX. However, as with all great books you need to do some work - and I would advise that you read the first "Tricks..." book first. When I started using this book it was hard going - I have no experience in Game Programming - but when I went through the first book and followed each example at a steady pace, including trying out the code I found the second book became easier when I returned to it.
This book is well written, and LaMothe clearly wants you to learn the inner concepts of Game Programming rather than just giving you a 3D engine. He clearly enjoys the subject - sometimes going over the top - but once you learn to find the important bits, you will be surprised how much you have learn’t from him.
In many cases he gives you 2 or more ways of doing things - for example using 8 or 16 bit, manual or matrix calculations and Euler or UVN Camera. My advice is stick to one method to the end of the book and then come back and update with the alternative.
A great book...After reading it you can probably develop the next Quake or Half-Life engine easily...
We all complain that there is too much maths in 3d game programming books but friends who told 3d game programming is easy? The best way to gain from this book is spend some time polishing your maths specially geometry. Trust me spending 2-3 weeks in the library will help you a lot to gain from this book. This book teaches you how 3d engines are written from scratch and full credit should go to LaMothe for explaning things in humorous way which some people may not like.You wont find any API’s here - only pure C/C++, of course you need VC++ 6.0 to compile the samples.This book is intended for intermediate to advanced programmers.My only complain is that the author should have covered level designing in detail but nevertheless I have enough information as to how that can be done. I would like to say that although books are important one should remember that most people who are in game business never had any good books to refer to when they started but yet they produced games which we marvel at. As of now making game is an art rather than science.
We all complain that there is too much maths in 3d game programming books but friends who told 3d game programming is easy? The best way to gain from this book is spend some time polishing your maths specially geometry. Trust me spending 2-3 weeks in the library will help you a lot to gain from this book. This book teaches you how 3d engines are written from scratch and full credit should go to LaMothe for explaning things in humorous way which some people may not like.You wont find any API’s here - only pure C/C++, of course you need VC++ 6.0 to compile the samples.This book is intended for intermediate to advanced programmers.My only complain is that the author should have covered level designing in detail but nevertheless I have enough information as to how that can be done. I would like to say that although books are important one should remember that most people who are in game business never had any good books to refer to when they started but yet they produced games which we marvel at. As of now making game is an art rather than science.
I’ve always struggled to get into 3D coding, books on DirectX and OpenGL just end up being API references, without giving me what I really need which is a good solid foundation on 3D coding techniques from the math (which you can gloss over the fine details if you need to), coordinate systems, camera systems, rasterizing etc etc.
Yes, a lot of what is covered is done in hardware now, but I feel so much more comfortable with 3D that tackling DirectX and OpenGL doesn’t scare me any more. Remember that new toys, such as PDAs and mobile phones do not have hardware acceleration yet, but they do have the speed for software renderers!
I’ve noticed others comments on the quality of the code and that it is in C instead of C++, and yes some of the function names are a little hard to follow and yes I would have preferred it in C++ but if you’re a competent programmer you should have no problems at all. The listings in the book are there for a reason, to make you look at them and try to understand what’s going on, the author summarises the code as well and it’s this continuous re-iteration that I for one find to be a good learning technique.
If your looking to learn 3D from the ground up then buy this book, you won’t be disappointed. You could certainly do much worse for £30.
I’ve always struggled to get into 3D coding, books on DirectX and OpenGL just end up being API references, without giving me what I really need which is a good solid foundation on 3D coding techniques from the math (which you can gloss over the fine details if you need to), coordinate systems, camera systems, rasterizing etc etc.
Yes, a lot of what is covered is done in hardware now, but I feel so much more comfortable with 3D that tackling DirectX and OpenGL doesn’t scare me any more. Remember that new toys, such as PDAs and mobile phones do not have hardware acceleration yet, but they do have the speed for software renderers!
I’ve noticed others comments on the quality of the code and that it is in C instead of C++, and yes some of the function names are a little hard to follow and yes I would have preferred it in C++ but if you’re a competent programmer you should have no problems at all. The listings in the book are there for a reason, to make you look at them and try to understand what’s going on, the author summarises the code as well and it’s this continuous re-iteration that I for one find to be a good learning technique.
If your looking to learn 3D from the ground up then buy this book, you won’t be disappointed. You could certainly do much worse for £30.
If you wanna make your own 3D engine and have absolutely no idea how to start, then get this book !
This will give you a much better understanding of how 3D graphics work than any book on OpenGL or DirectX. The book teaches you to build a software-renderer in C from start to finish, including texturing, lighting, animation, scripting, ... , processor optimizations. The lay out is very logical, and all the techniques and concepts are illustrated and explained very well.
The code does look ugly at times, but if you follow it from the start, you won’t be lost or confused.
It would have been better if his code was written in C++ and not C, but that’s only a minor issue.
If you wanna make your own 3D engine and have absolutely no idea how to start, then get this book !
This will give you a much better understanding of how 3D graphics work than any book on OpenGL or DirectX. The book teaches you to build a software-renderer in C from start to finish, including texturing, lighting, animation, scripting, ... , processor optimizations. The lay out is very logical, and all the techniques and concepts are illustrated and explained very well.
The code does look ugly at times, but if you follow it from the start, you won’t be lost or confused.
It would have been better if his code was written in C++ and not C, but that’s only a minor issue.
If you DONT want to use DirectX 3D API, then go with this book. As LaMothe says "Math, Math,...etc” in software mode, with C.
The coding is not tidy. And the routines all look alike throughout the whole book at a glance its (x,y,z on every line).
The accompanying CD is worth a five-minute browse, yes I’m not kidding.
LaMothe admittedly wrote this book without a specific direction. So there’s lots of
subjects covered. The best page of the book explains how to use CASE tool optimisations.
I was looking for a book with lots of references to common black box D3D9 functions. Incidentally I still haven’t found an advanced reference book on D3D 9, so I can only recommend the Microsoft SDK help as a free alternative.
This book doesn’t really touch on DirectX or proper games programming, but thats a good thing! Instead the whole book really does take you through the steps of creating your own software rasterizer - learning how something like DX or OpenGL works on the inside. If you want to be amazing at DX then this is information you need - u cant properly use the tool without knowing how it works. Writing style is great, and the author really is creating the engine as he is writing the book, instead of creating the engine and then writing the book! This makes it a lot easier to see what has been going on in the authors head, but can cause some confusion when he changes his mind about something half way through.
Although it covers cameras and 3d math, this info can be found in many other books. However the important bits were as follows:
-rasterizing triangles, i.e. projecting the 3d world onto the 2d screen
-all kinds of interpolation techniques - gouraud shading, perspective texture mapping, z buffering
-a very in depth part about clipping which is a BIG topic
-strong focus on optimisation with lots of little tips to make things faster
-quake II .md2 model format loading/display
Don’t get me wrong - there is LOADS of other info in this book on just about every 3d graphics topic, but above is things that I couldn’t find anywhere else. It doesn’t just tell you HOW to do them, it tells u how they actually work.
My only problem was that he does refer back to his previous book, The Zen of 3D Game Programming, occasionally which I haven’t read, but you can easily get by without it.
So, to sum up, dont buy this book expecting to come out the other end with a working game engine or in depth knowledge of a particular 3d accelerator - it is a book about the theory and math of 3d graphics. Buy it because it is the best source of information that you NEED to learn to become an expert, and it is well written, well structured and generally... GREAT!
You must login first, to write an comment/review!
Optimized for Internet Explorer 6.0+!