Please use and bookmark only this resource from now!
Send News
Added 11 Oct 04 Updated 02 Dec 08
Publisher Sams
Publication Date 2004-12-13
Paperback - 432 Pages
ISBN 0672326612
Beginning 3D Game ProgrammingAbout the Author
Tom Miller is the designer and development lead for the Managed DirectX API. He has worked at Microsoft since 1997 where he started on the Visual Basic team before his love of games and game programming took him to the DirectX team. He has been with the DirectX team since late 1999, and has worked to bring the DirectX API (and game programming in general) to a wider audience. He has also written the definitive book on the Managed DirectX libraries to date.
© Copyright Pearson Education. All rights reserved.
There are many programming hobbyists who write 2D games but there are far fewer that grasp the concepts of 3D programming. Although there are also quite a few ¿game development¿ books on the market, few deal with 3D game development. Those that do are mainly aimed at advanced readers. This book will provide a practical, example driven approach to learning the unique art of 3D Game Development that even the beginner can grasp. It won¿t get bogged down in page after page of boring theory but instead will teach through many interesting hands on examples. Tom Miller brings years and years of 3D game programming to the table and couples that with an engaging writing style to mentor readers in the intricacies of game development. The book starts out with a crash course in game programming concepts and then progresses into developing 3 different types of games with many useful tips, notes, and cautions along the way. This title will serve as a useful guide to either current 2D game developers or programmers that want to learn to program games.
Details;){kind=link}
The quality control is poor, many spelling mistakes and there is lots of code missing from the examples in the book. Can be quite time consuming to get anything working and requries, I think, a lot of knowledge about development environments in order to get anything out of it.
i have to say, that for someone who wants to use C# and directX this book is a one stop shop, i think that the general idea of this book totally hit the right point,
yet, there are a lot a lot, of code errors, in the printed text,
and when you get an error on the introduction chapter,
(the "device" word),
you may question, how seriously did these people take them selves,
and, when you do not include an Appendix on how to install the SDK’s...
then with all respect, you cant say this is a book for beginners,
if i was a beginner, i would probably leave the book, around chapter1 with the "device" error, and the assmupsetions of a working sdk.
the book is very good, but everything around it is very very bad.
This book is a decent learning tool, especially if you make sure to use the included CD. However, without the CD, you would find yourself completely lost, because the code written in the book is chock full of errors. It’s almost as if nobody ever bothered to actually read the book prior to publication. The code on the CD compiles just fine, though, so if you want to learn from this book, you just have to double-check all of the code against what’s on the CD.
This is not a book for beginners. It’s way above beginner level. And the sample code doesn’t work.
I was conned into buying this book by the title and the fact that it uses C#. Unfortunately, it’s totally incomprehensible.
This is not a book for beginners. It’s way above beginner level. And the sample code doesn’t work.
I was conned into buying this book by the title and the fact that it uses C#. Unfortunately, it’s totally incomprehensible.
I cannot proceed because of the errors and there is no place to go to get answers. The author needs to offer tech support before I can recommend his book. Except for the errors, I find the book to be easy to follow and I think the examples of 3D games are relevant, understandable, and interesting. The source code and DirectX Managed Code would make it easy to quickly get something running if it weren’t for the above mentioned errors. It would have been just what I need for my plans to teach 3D Game Animation to Middle School students. I want them to have working models that they can tweak. A spinning teapot is an excellent place for them to start. The Blockers game is a good next step. The Tank will appeal to many students. The explanation of multi-player games is essential to my curruiculum. A word of warning - Visual Studio is required, don’t try it without.
Personally none too impressed with this effort. Tom Miller obviously has the ability to create 3D games, but his attempt at allowing the book buying public the chance to learn some of his skills didn’t help me a bit!
Explanations were introduced at a far higher level than I would have liked, and the learning curve seemed to go from 0-200 mph within around 5-6 pages.
Examples didn’t work, and I actually had to scour the internet for solutions from other readers, in order to progress with the book!....
Save your money!!!!!!
I see that some readers had good results from this book while others were frustrated. I’m afraid I’m in the latter category. Being new to the whole .NET world, I lack the experience to fill in the blanks regarding details the author omits. I have been unable to see any of the sample meshes, or to get the compiler to locate the DirectX classes. Based on other reviewers’ comments, it’s clear that these things are possible, but one cannot achieve them by following the instructions in the book.
I don’t question the author’s qualifications. I think the difficulty lies with the publisher. For hands-on tutorial material, especially when it is aimed at beginners, it is important to do a real hands-on review prior to publication. It isn’t sufficient to edit the text for grammatical errors and leave it at that. Had the publisher actually tried to use the book, they would have encountered the same problems as I and others have encountered within the first 15 minutes. It is not acceptable to approve tutorial material for publication unless and until it has been verified accurate and usable by the intended audience. I will be very cautious about purchasing books from Sams Publishing henceforth.
Let me begin by saying that I went through no less than five DirectX game programming books before checking out Miller’s book on a friend’s recommendation. Most of those other books (some of them decent) used C++ as their code base - as you’d expect. I spent my entire college career coding C++, so I was no stranger to the language. But I found most of those books difficult to crack. DirectX 3D programming in C++ is just not intuitive for beginners.
Enter Tom Miller’s book. You should know I had very little experience programming in C# before I got this book. Now I’m a total convert. Middleware aside, I just don’t think there’s a faster, more intuitive way to create your own 3D games than using Managed DirectX.
I found Miller’s book to be well written, clear, and having a reasonable learning curve. He starts you out slowly, and adds complexity with each game project. Add in the ease of reading and programming in C#, along with the Managed DirectX sample framework, and you’re starting out ahead.
That is not to say that Miller’s book is perfect. But I found most of the faults lie with Managed DirectX itself (although I suppose Miller should share some of the blame since he’s the one creating it :) Because this is "new" technology, the MDX API keeps changing. Your code may not work from one SDK update to the next. Hopefully most of this will settle down with the release of Visual Studio .NET 2005.
If you’re having trouble getting the source code on the CD to work, don’t fret - it works. But depending on the version of the SDK you have installed, you may have to do some minor massaging of his code, specifically to his main game object. If you’re annoyed by this, I don’t know what to tell you. A quick Google search and some source code cut-and-paste had his code compiling with minimal effort. And this was when I knew NOTHING about C#, DirectX, the sample framework, or Miller’s code.
I was able to create a fairly complex 3D puzzle game in about 4 months. Honestly, it turned out great and exceeded my expectations. And I based my original code on Miller’s simplest game example. Granted by the end of development, there was almost nothing left of his original code. But that’s what was so great about it - I could make some minor changes, compile, see what happened. Add a new object, compile, see what happened. I got instant feedback through the entire development process, and that made a HUGE difference for me. I never felt like I was programming into a black hole, hoping I’d get workable code at the end.
Again, this book (or Managed DirectX, for that matter) is not perfect. You will have to put in a little effort. But honestly, if you’re not willing to put in the effort, why would you be interested in game programming? It’s a labor of love, with an emphasis on labor. When it comes right down to it, I just don’t think you can do better than this book if you have some programming experience and you’d like to try your hand at creating a 3D game.
I borrowed this book from a library. I read the beginning and it seems very promising. Unfortunately it had no CD. If somenone could help me with the source code, please e-mail me at (...)
I confess I’ve yet to finish the book - I’m only on Chapter 15 but I’m infuriated enough to come on here to warn folks about this book.
I’m giving this book 3 stars as its almost the only book out there that is even on the topic of writing REAL games using Managed DirectX, certainly with a recent(ish) version of the MDX SDK. Also all 3 projects compile and run almost without issue. You may well need to tweak the setup code as there is needless criteria in there to ask for a ninja graphics card when a Ford Fiesta will do for these basic games.
Rather than a book of general information about writing games, this is much more a straight tutorial, an example of 3 games, well two and a bit (more of that later) built bit by bit. Not so much time is spent on the structure of the code, more a code listing and a paragraph to explain things.
The book starts off well enough, although the scant information on directX flies in the face of the "Beginner" tag in the title. I’d recommend you read Tom’s first book before delving into this ("Kickstart Managed DirectX, which is a great book). . Also it uses the Sample Framework of the MDX SKD, the Callback based one.
The first game is a nice little puzzle game called "Blockers". OK there are many times when the source code in the book is not correct and you need to delve into the CD to find out how you’re REALLY supposed to do it. Nothing major, usually the method signatures are out of date, perhaps Tom changed his mind about a few things after the text had gone to press. Also several of the Graphic figures in the book are totally wrong often repeating an earlier graphic. Unfortunately one of these was a "code overview" diagram so you’re left in the dark about the big picture before you get started. Dunno how that got past quality control but there you are.
However ALL the source code for "Blockers", whether its correct or not IS in the book. There’s even an appendix with the source code for a level creator for the game in the book. Which is 100% correct.
Next up is "Tankers" apparently a multiplayer Tank combat game. Tom introduces you to this in the same way as "Blockers" but then lets it all go halfway through the user interface. As if he gets bored he advises you to check the CD out to implement the User Interface.
The sad thing is that there is not *that much* missing but you’ll be picking around for quite a while as its not even clear what needs to be achieved. I had to run the CD code to see what the UI was even supposed to look like. This is when I noticed that stuff like the collision detection was not working. Also you’ll need to implement parts of (discussed in later chaters) new classes in order to get your project to compile.
Tom does this again to you later on in "Tankers", to save only about 1 or 2 pages of code in the book. Not so much a big deal but shows what is happening with the Author...he is out of time on this and begins to rush to the finish.
Before we get onto "Game 3" there are smatterings about what’s in store in the "last game". "In the next game. You’ll have more in-depth sound features", it says. Pah! NOT!
Game 3 is not a game at all. Its all given away where Part 5 of the book is entitled "Advanced Graphics, Client/Server Networking". Would have been nice.
But the only client / server stuff was done already in part 4.
Tom shows you just rendering some static models on screen using some basic shaders and leaves it at that. No game.
Again its sad that this was so obvioulsy planned to be a nice multiplayer Kart Racing game but seems that the deadline, which was already months over for this book, got the better of Tom and its just not there. And that advanced sound? Nope! Not a beep.
So I guess this book was started with great things in mind but soon after you finish "Blockers" it goes downhill rapidly.
There are not 3 games in here - only 2, plus some graphic experiments which are then plastered on the book cover (VERY misleading). the back cover of the book clearly says, "The book includes detail explanations and source code for three complete games". As I’ve said, this is just not true.
Its not like you have much choice if you’re looking for a book on this topic but unfortunately this one just loses it halfway through.
Its rushed. Its a con. Its a shame.
First of all I’d like to say that this book’s title is very much misleading. This book is not for the absolute beginners like my self. You really have to know your C# programming skills before even touching this thing. The author claims to not bore you with all the terminologies like, "Cool man and awesome," but in the attempt he’s missed out a lot of important steps as well e.g. installation process and getting yourself ready to start this book. He tells you to install the tools like Direct X Summer Development Kit and also gives you some steps to use them, but they are not enough for an absolute beginner.
Secondly, while I was trying to install the Direct X Summer Development Kit, it gave me an illegal operation error and exited the installation. This happened to me about 5 or 6 times, and you know how frustrating that can be. So, on I went to download the latest version of the Direct X Development Kit. Now that the new version worked, YEY, I found some major changes in it as compared to the instructions in the book.
It took me about 10 minutes but I got around it.
Finally, moving on to the first chapter of this book, displaying a tea pot, I did exactly what the book asked me to do the instructions seemed to be simple enough, but to my surprise, I got 6 compilation errors. I thought about checking the version on the CD, but there was no example of this exercise on it. That’s when I said to my self, I am wasting my time.
I then decided to return this book and thought of moving to something else. My advice! Please find something that’s worth while, and don’t waste your time on books like this one. Do a lot of research, read reviews from others, do whatever it takes to get yourself on the right path. It will take some time for that as well but, you know what? In the end you will save time and not lose hope.
This is one of the only books in print which covers Managed DirectX game programming. Many of the other books on DirectX 9 still use C++, leaving those of us who prefer Managed code in the dark. Since Tom Miller is the author of the API, he is one of the best people to introduce you to this material. This book does have quite a few errors, but I still think it’s one of the best books around. Despite all of the errata, I’m giving this book four stars because it provides a very comprehensive intro to DirectX 9 and 3D game programming.
If you don’t have a good understanding of 3D math, I suggest looking for an additional textbook which covers matrices more comprehensively. Fortunately, DirectX reduces some very ugly matrix multiplication to look like simple math problems and I could see some people using DirectX without knowing much about trigonometry or matrix math.
This book also gave me several realizations:
1) I need a computer and graphics card with Pixel Shader 2.0.
2) I need to become a better artist so I can create my own meshes and skins or I have to pay someone else to be the artist.
In the beginning of the book, several programs are mentioned for creating meshes. In additional to those professional (and therefore expensive) packages, I thought I’d mention a program called MilkShape which only costs $25 to register and does a pretty good job of creating meshes. It exports into many formats, including DirectX.
Unlike Tom’s previous book, the code in this book relies on the Sample Framework which ships with this version of DirectX. It does seem to remove some code requirements, but I think it also weighs down the code unnecessarily. I think in some ways it might have been easier to understand the code without the sample framework. The book isn’t really a sequel to Tom’s other book, but it’s more like a repackaging of ideas with a focus on game programming.
The code does compile, but you need to make sure that you have the references to the October 2004 release (v9.02.3900). If you have multiple versions of DirectX, the framework is going to default to the newest version.
I do have to say that I felt the frustration of the previous poster who found the book to be full of errors. There are many incorrect diagrams, many instances of incorrect code, and even a small error in the section on matrix multiplication (a second edition is definitely needed). Fortunately the source code is correct, so you can always look at the code to find the necessary corrections. The book also claims that VB.Net code is provided in the source code, but I could not find it anywhere (it’s all in C#). I’m not sure why the code was never translated, but perhaps it was the unsafe code (some of which could have been avoided using Marshal.SizeOf) or perhaps it’s because there are many cases where a variable has the same name as a property but with a different case.
In the first project, there is at least one critical line of code that never shows up in the book but is in the source code. Most of the errors relate to references to "device" with need to be replaced with either "e.Device" or "sampleFramework.Device".
In the second project, the author leaves you on your own in the middle of the project to figure out the UI design. Normally I wouldn’t have a problem with that, but the UI actually uses some classes which aren’t discussed until the ensuing chapters. It would be more helpful if the source code provided an incremental copy of the code for each chapter which shows only what’s been done up to that point (rather then just the final result). It would also help if at the end of each chapter you could have a definitive result to compile and display (if only to tell that you haven’t missed something). As an aside, the collision detection routine is also less than perfect, since you can make the tank go through some walls as well as off the playing field.
The third project is not a complete game. It is simply a program that’s been started and left for the user to finish (so I take issue with the claim on the back of the book that there are three complete games). The source code is no more complete than what’s in the book (whereas the first two games are complete in the source code). But it does teach you some really cool stuff about the programmable pipeline, and if I had a card with pixel shader 2.0 I might be able to view it faster than 0.5 frames per second.
I think it would be helpful if the errata were published on line, as well as the source code (for a while I had lost the source code for Tom’s previous book and couldn’t find it anywhere on line). Tom’s blog has some discussions, but I couldn’t find errata or source code (nor could I find it on www.samspublishing.com). I’ve tried sending some comments to him on his blog, but I haven’t heard back.
To sum it up, this is a great book despite all of the errors. Kudos to Tom for helping bring DirectX to those of use who want to write games using managed code.
I was expect high standards from this book given that is was from Sams Publishing, but it looks like no one proof read this book. There are missing or incorrect images throughout this book. When pointing this out to Sams Publishing, they fobbed me off telling me that they would get in touch with the author to get him to send the missing or incorrect pictures. I am still waiting 2 months later. I would say ignore this book, unless it is second edition. I just find it would be a good book, if someone had check it out first. Nevermind, try again. :(
C# and Managed DX9 are arguably the easiest way to write understandable 3-D code. You don’t have to mess with all of the convoluted C++ jargon and strange uses of variables that are initialized after passing them to methods.
I cannot stress enough how useful this book has been in the current game I am working on (a 3-D RTS). The chapters on User Interface and how to write a custom GUI have been particularly useful with where i’m at now.
This book would have also saved me tons of time earlier in the development process as he goes over such simple things as handling device lost states (such as when the user minimizes your game) and how to display an accurate framerate (I wasted tons of time on that last year!).
Tom also shows you how to write networking code to make a multiplayer game as well as how to do things such as have a nice skybox, multiple levels, loading screens, player selection screens, font output, and even the use of Shaders (to make objects shiny). He also shows how to do mesh animation using mesh hierarchies - which is very important if you want your model to be able to have different moving parts that animate (such as for walking).
This book covers a wide breadth of topics that any new programmer to game design will find useful. If you pair it up with his Managed DX9 Kickstart book (which you should read first probably), it will take you to the point where you can write your own framework for just about any game you want to write. It does not cover really advanced topics such as pathfinding algorithms and fancy AI code, but it will give you a broad overview and allow you to write several fun games (I’m especially fond of Blockers).
I confess I’ve yet to finish the book - I’m only on Chapter 15 but I’m infuriated enough to come on here to warn folks about this book.
I’m giving this book 3 stars as its almost the only book out there that is even on the topic of writing REAL games using Managed DirectX, certainly with a recent(ish) version of the MDX SDK. Also all 3 projects compile and run almost without issue. You may well need to tweak the setup code as there is needless criteria in there to ask for a ninja graphics card when a Ford Fiesta will do for these basic games.
Rather than a book of general information about writing games, this is much more a straight tutorial, an example of 3 games, well two and a bit (more of that later) built bit by bit. Not so much time is spent on the structure of the code, more a code listing and a paragraph to explain things.
The book starts off well enough, although the scant information on directX flies in the face of the "Beginner" tag in the title. I’d recommend you read Tom’s first book before delving into this ("Kickstart Managed DirectX, which is a great book). . Also it uses the Sample Framework of the MDX SKD, the Callback based one.
The first game is a nice little puzzle game called "Blockers". OK there are many times when the source code in the book is not correct and you need to delve into the CD to find out how you’re REALLY supposed to do it. Nothing major, usually the method signatures are out of date, perhaps Tom changed his mind about a few things after the text had gone to press. Also several of the Graphic figures in the book are totally wrong often repeating an earlier graphic. Unfortunately one of these was a "code overview" diagram so you’re left in the dark about the big picture before you get started. Dunno how that got past quality control but there you are.
However ALL the source code for "Blockers", whether its correct or not IS in the book. There’s even an appendix with the source code for a level creator for the game in the book. Which is 100% correct.
Next up is "Tankers" apparently a multiplayer Tank combat game. Tom introduces you to this in the same way as "Blockers" but then lets it all go halfway through the user interface. As if he gets bored he advises you to check the CD out to implement the User Interface.
The sad thing is that there is not *that much* missing but you’ll be picking around for quite a while as its not even clear what needs to be achieved. I had to run the CD code to see what the UI was even supposed to look like. This is when I noticed that stuff like the collision detection was not working. Also you’ll need to implement parts of (discussed in later chaters) new classes in order to get your project to compile.
Tom does this again to you later on in "Tankers", to save only about 1 or 2 pages of code in the book. Not so much a big deal but shows what is happening with the Author...he is out of time on this and begins to rush to the finish.
Before we get onto "Game 3" there are smatterings about what’s in store in the "last game". "In the next game. You’ll have more in-depth sound features", it says. Pah! NOT!
Game 3 is not a game at all. Its all given away where Part 5 of the book is entitled "Advanced Graphics, Client/Server Networking". Would have been nice.
But the only client / server stuff was done already in part 4.
Tom shows you just rendering some static models on screen using some basic shaders and leaves it at that. No game.
Again its sad that this was so obvioulsy planned to be a nice multiplayer Kart Racing game but seems that the deadline, which was already months over for this book, got the better of Tom and its just not there. And that advanced sound? Nope! Not a beep.
So I guess this book was started with great things in mind but soon after you finish "Blockers" it goes downhill rapidly.
There are not 3 games in here - only 2, plus some graphic experiments which are then plastered on the book cover (VERY misleading). the back cover of the book clearly says, "The book includes detail explanations and source code for three complete games". As I’ve said, this is just not true.
Its not like you have much choice if you’re looking for a book on this topic but unfortunately this one just loses it halfway through.
Its rushed. Its a con. Its a shame.
Tom Miller has succeeded once again with writing an excellent book that assists those of us who are using Managed DirectX and C# instead of the more typical C++ with Un-managed interfaces.
This book is fairly easy for the beginner, but does cover other topics such as using DX9’s custom interfaces to make GUIs for your games. This has been very helpful with my project that I started after reading Tom Miller’s first book (Managed DX9 KickStart), which is also an excellent book for beginning 3-D Game programmers.
The source code included is well written and the author is responsive to questions on his blog at: http://blogs.msdn.com/tmiller/
You must login first, to write an comment/review!
Optimized for Internet Explorer 6.0+!