Customer Reviews

Beginning DirectX 9 (Game Development Series)

5 star:		(4)
4 star:		(5)
3 star:		(1)
2 star:		(6)
1 star:		(4)

 

 

I was initially impressed with this book, even after seeing a couple pages of utter garbage in the first part. All I wanted was a quick review before my serious books came, and having programmed DX before I could promptly correct and move on, but enough was enough!
I can best describe parts of this book as rough notes fed to a blender and then pasted into the chapters with a leaf-blower. That goes for the `code' samples as well.

For a complete beginner these errors may be significant enough to possibly detract and frustrate the learning experience. Not a good thing, especially considering that's the book's targeted audience. There is no excuse for this.

More advanced developers will cringe and cringe until they finally damage something or hurt someone as they throw this waste across their office. Also not a good thing.

An alternative book that covers the same ground quite a bit more soundly is Frank Luna's Introduction to 3D Game Programming with DX9, which I finally received & promptly read from one end to the other & moved on to other books now. It's a solid work bolted tight with some good code.

2 Stars, for a publishing a work containing some content I wouldn't even turn in as homework.

Beginning DirectX 9's strong points are solid organization, simple language, great introductory examples and good content. Its weak points are the supplementary CD examples (most of which do NOT work), its typoes and poor proofreading.

The first thing the avid programming-book reader will notice is that a good 66% of the book is devoted just to Direct3D! This might seem like a bad thing, but after having read the entire book, the reader does acheive a satisfactory level of coherence and familiarity with the many interfaces discussed. The author, Wendy Jones, explains the major components of DirectX with a consistent approach of first introducing the steps of initialization and utilization and then diving into the specifics. This repetitive style allows the reader to grasp the parallelism of the various components of DirectX and not be too intimidated by it.

Jones steers away from getting too hefty on the advanced computer lingo (or the "Chapter 4: Well i'm showing you this, but it can be done using orthonormal orientation vectors that i'll explain later in chapter 52"-type statements popular to this genre ehem Lamothe ehem Luna). Instead, she gives the reader the essential materials necessary to implement the newest version of DirectX in the simplest language and content possible. Where confusing off-topic structures were optional, she completely avoided them and this leads to fast comprehension.

To get you started, the author gives one of the most superb examples I've seen on the topic. All it does is setup the D3D device, set the mode and clear the screen blue, but it's a matter of what complexities she avoided to get the point across: programming with DirectX IS POSSIBLE! Other examples are not as specific, not so much a walkthrough but will give the reader the tools he/she is looking for.

The pitfalls begin when you pop in that supplementary CD-ROM; (I often check those out first to get a gist of the scope of the book and what I'll be learning). Barely any of the executables run! Consequently, the reader is left not deciphering the code that already works but trying to decipher the text so he/she can hopefully get their own example running. The CD-ROMs in game programming books can make or break them, in this case, it harshly affected my opinion of the text.

Another downside to the book is the poor proofreading the publisher did! Keywords like 'if' are spelled 'If'! RGB is sometimes spelled RBB. This sentence was also allowed to print: "DirectInput, like other components of DirectX, is initialized in a similar manner to other DirectX components." This is not only redundant it's nonsensical. Though these be entertaining, they are CONFUSING and make one doubt the validity of further code snippets and interface explanations.

So it seems this books high points are as high as its low points are low. (If my rating for this book were a 2D sprite, its y position would be indirectly proportional to its z-buffer) Ineffective jokes aside, Beginning DirectX 9 is definitely a worthwhile read. It will give you that general introduction that you desperately need and not discourage you with the complexities of DirectX. Though a little editing might have been needed, its strongpoints overcome.

There is already a review of this book that gives a very good description of it's strengths and weaknesses by M. Velez "gpbook dork". I just wanted to support some of his facts.

Chapter 4 and 5 are horrendous, the first chapters on 3D rendering. It switches CUSTOMVERTEX structures without any notice and stops giving compileable examples. Even within subsections the variables used to represent a particular buffer change.

There are comments that define the structure, and then the structure is different (XYZ_UV in the code snippet comment, and then XYZ_ARGB in the code).

The most insulting error takes place on page 96 in Chapter 5. Keep in mind at no point has the word "dolphin" been used in the book prior to this (my comments *'ed):
// Set the indices to use
m_pd3dDevice->SetIndices( m_pDolphinIB ); // *I thought we were calling it iBuffer... and is it m_pd3d or pd3d?
// Call DrawIndexdPrimitive to draw the object using the indices
m_pd3dDevice->DrawIndexedPrimitive( D3DPT_TRIANGLELIST,
0, // BaseVertexIndex
0, // MinIndex
m_dwNumDolphinVertices, // NumVertices *When did we declare this?
0, //StartIndex
m_dwNumDolphinFaces ); // primitive count *We didn't declare this either

So we locked a different buffer and then draw this out of the blue buffer? It's insulting to think I bought a book that clearly uses the code from the DirectX provided samples.

There are much better books on introductory DirectX, and this one is just a ripoff of the DirectX tutorials. Do not expect ANY intermediate or advanced topics out of this book, I know it never claimed to, but most "beginner" books I have read go a bit further than this.

... any typos in my post are meant for irony (what do you want... i'm a programmer not an editor, i can't spell correctly)

I have several DirectX books and this one is the only one that I actually learned from. Hopefully I will be able to use the knowledge gained from this book to help me through my other books. I feel I can only give this book 4 stars though. As far as the book goes, it is very well written. Concepts are explained to you first, and then implemented. The author never throws more than a page of code at you at a time. However, there are some complaints. For some of the functions, the author doesn't say what actually calls them. This can lead to confusion if you are trying to do the code yourself and then checking it (which is the preferred way of learning). Also, the author doesn't point out all the things you need to change to move from one example to the next. Often the compiler will give you warnings or errors that you have to fix, although they are trivial in nature. A major complaint is that half of the .exe files on the cd do not work, and one of the directX updates doesn't seem to be a valid Win32 application, although I'm pretty sure the other update on the cd covers it. A problem I had was when the author chose to create the device using the Microsoft REF in one of the parameters. To get the example to work I had to use the HAL. After that everything worked just fine. This is a good introduction to directX and you will benifit greatly by owning it. You should also get another book that goes into more detail, after you have mastered the basics.

I have come back to edit this review and knock the star rating down to 3. In the chapter about lighting, there are no examples of using any light besides ambient light. When you try to use other lighting techniques, you get no results. Here's what I found out, after looking through the DirectX SDK Documentation, and samples. ** You have to use surface normals **. Thats right. Nowhere in the chapter did the author state you have to change your vertex definition to include the D3DFVF_NORMAL flag. For anyone who may be stuck in that chapter, this is probably your reason. Also, for texture mapping, you have to use the vertex buffer, not the index buffer, to get the correct mapping. It would've been nice had this been stated. To reiterate, the examples in this book are completely useless. In fact, I found much of the book taken word for word out of the SDK. It is still a good book to have though. It is the only one that has helped me learn DirectX. Just be prepared to look through the SDK documentation, especially in later chapters. Perhaps Wendy Jones was not the most qualified author to write this book. It seems like she's just familiar with the material in the book and is uncomfortable presenting some ideas clearly.

This book has helped me to finally figure out directx
after looking in other books and not getting anywhere.
It touches a little on 2d programming in direct3d but
focuses mostly on 3d programming. Direct input and
direct sound are covered also.

The 2d section covers making animations with bitmaps,
but without transparency. If you want to do 2d
transparency with the 2d techniques in this book you
will have to use a graphics format that supports transparency
(such as png) and you will need graphics creation software
that can create transparent images (I use paint shop pro)
Transparency will only work this way in 32 bit color.
The issue of transparency and color mode will not be an
issue for 3d programming.

This book covers a lot of area in the 3d realm. Chapters
3-8 deal with 3d. Explained are vertex buffers, index
buffers, matrices, camera positioning, shading, lighting,
texture mapping, meshes, and more. I haven't yet programmed
anything 3d but my impression after reading most of the
3d sections is that you'll get a thorough coverage of
3d with this book.

I would recommend this book for anyone who is a beginner
to DirectX but well versed in C++. This book uses
Visual C++ .net, which I have, so I'm not sure how well
this book would work for someone with a different compiler.
If there are any unanswered questions you have that this
book leaves out along your way to developing a game,
I would consider going to the forums at www.gamedev.net.

After buying quite a few books that I thought would help
me develop a game and getting nowhere, I am quite impressed
with this book.

This is a very nice introduction to DirectX 9, although it's a little confusing as to why there is also a Beginning Direct3D 9 book also by this publisher, that covers the same material (but written by a different author). The reason I make this comparison is because this book is about 80% Direct3D, and the other 20% covers DirectInput and DirectSound.

But, I would have to say, I enjoyed this book more than Beg D3D because it is easier to read, definitely a good choice for a beginner or an experienced programmer who wants to get up to speed with DX9.

I bought this book because I was very impressed with another Thompson book. "Beginning C++ game programming.". Unfortunately, this tome doesn't live up to that high standard.

I almost never use the CDs that come with programming books. As I prefer to type in the lessons myself. However I was forced to pop in the CD on the first chapter of this book when my code would not compile. Imagine my surprise when I opened the solution and saw "if( PeekMessage( &msg, NULL, 0U, 0U, PM_REMOVE ) )" where the book had told me to type "while (GetMessage(&msg, wndHandle, 0, 0))". Huh?

It didn't get any better after that. The text is poorly written. The editing is abyssmal. Maybe it gets better later on, but I'll never know. Because I'm not going to waste any more time on this piece of garbage.

This book is entitled "Beginning DirectX 9" and not "Make a Killer 3D Game Engine in 20 Days." One can see from the detractors comments that they certainly don't sound like beginners, do they?

I have successfully taught DirectX to many game programming students using this book. Wendy Jones gets right to business from the very first chapter and explains 2D and moves to 3D swiftly. This is a great book for $20. It's been more useful than a few books by the same publisher that cost more than $40.

(The publisher has a few books on this topic. This is the result of having inherited Andre la Mothe's collection of game development books.)

Yes, this book does suffer from the typos that have been mentioned. Many programming books have typos in them, as well as on the CD. That is nothing new. It's the publisher's fault for using non-technical people to proofread and manufacture these things. These issues get resolved in second and third printings.

The content is great, and I have proof in the form of many students who can attest that they learned what they needed and wanted to from this book. Yes, they had me as an instructor, but I was not holding their hands and explaining every last concept.

After you get your first DirectX programs running with this book, you can move on to other books and tutorials available on the web and have a much better grasp for the new material you'll learn there.

No book is ever going to be perfect. Look at reviews of the 3D Engine books and you'll see even more conflicting reviews, based on the author not having covered one or two specific topics that people were looking for.

The subject matter is not about doodling with crayons. You have to apply yourself when you come up against conflicts between something on the printed page and on a CD. If you can't really do that, then you should reconsider whether your C++ skills are even at a place where you can properly take up DirectX programming at all.

I am an average programmer who is self taught, and I bought this book to introduce me to DirectX9. I liked the layout and simplicity of the book at a first glance so I bought it....and now I must say this to new buyers. There quite a few inconsistencies and typos... and I mean SERIOUS TYPOS, the kind that cause 3hrs of headache and time-wasting agony. Even in the first chapter. If I was not familiar with win32 programming this book would have been placed in trash can. I have never written anything bad about a book before, because I have never been so upset from one.....
OK.. NOW The good part -- why I gave it 2 stars and not 1. When it comes to the DirectX9 info, I believe that so far (I am at chp.6) I think it's information is very clear and informative.
I do give them credit here.

I couldn't find anywhere online for typo correction for books, even on the publishers page. I still hope to find something.
I cannot recommend this book unless you get the online version (and that is only if it has been updated). Check page 12(bottom) compared to 22(bottom) and see if the statements are the same:

p.12
while(GetMessage(&msg,....
p.22
if(PeekMessage(&msg,.....

this means quite different things.(btw p.22 is correct)

Luckily you have the CD to check against to see what it should be. But Some of the samples didn't link to the correct files.
chp.7
example 3
needs relinked to a folder in the sdk.
chp.7
example 4 needs to contain the sample file.

There are 11 chapters and I am at #6. The problems have been less and less as I go through the book. If you buy this book, it can be frustrating at chp.1. But it does get better.

Hope this helps someone.

The code examples in this book simply do not work. You have to rely on other books and looking up things yourself on the internet to get the examples working. If I wanted to do that, I wouldn't have bought THIS book!! Its thourogh in its coverage of DX9, but so are a lot of other books that have code that actually compiles. Don't waste your money. A programming book with programming examples that don't actually work is like a cookbook without any actual recipes. Useless.