This unique book focuses on offering a comprehensive solution to sucessfully building a Direct X user interface library from the ground up for games and other multimedia software.

Source Code too simple and of little value for a real game.

This book is really out of date and is not the GUI toolkit I hoped it would be. I bought this book hoping that I would be able to copy and paste in the code into my project but that isn’t going to happen. The code was rushed together and isn’t very impressive. There’s much more in the GUI sample that displays all the Directx ui widgets in the DirectX SDK.

Originally very excited about the book

Many other reviews covered this but I will briefly restate what others have said.



PROS (not many)

- Easy reading book.

- Doesn’t assume too much on the part of the reader. DirectX basics that are used was covered, etc.

- I don’t agree with all of the control messaging system but the author’s coverage/design is not too bad.



CONS

- As stated before, code in book does not match code on CD. Code on CD has some compilation issues that upon investigation are fairly straight forward to fix. Fixing requires knowledge beyond the basics of programming.

- The compiled executable examples, with very little happening on the screen, run very very poorly. I believe one of the basic issues with performance is with the overall design. That’s a problem because then the book is pretty much useless. I suppose to be fair the writer might have been targeting a larger audience and not just gamers. WM_PAINT posted messages are done. That’s slow. No respecting game engine will post paint messages, they will gain full control over rendering the window or full screen and "talk" directly to the Direct 3D device interface.

- (This one is personal) I do not like the coding style. Also, anytime a C++ programmer use "this->" the "this" pointer within the object itself doesn’t fully understand that you don’t need to fully qualify the pointer.



If you’re looking for decent code with somewhat decent comments then save yourself some money and just download the DirectX SDK. In it, you will get many examples of UI things. Microsoft created a CustomUI application which runs very, very fast and handles GUI things very similarly to this book. But Microsoft’s runs much faster. The problem with that is you won’t find a very detailed writeup on "why" things are done the way they are. At least I haven’t found it.

Originally very excited about the book

Many other reviews covered this but I will briefly restate what others have said.

PROS (not many)
- Easy reading book.
- Doesn’t assume too much on the part of the reader. DirectX basics that are used was covered, etc.
- I don’t agree with all of the control messaging system but the author’s coverage/design is not too bad.

CONS
- As stated before, code in book does not match code on CD. Code on CD has some compilation issues that upon investigation are fairly straight forward to fix. Fixing requires knowledge beyond the basics of programming.
- The compiled executable examples, with very little happening on the screen, run very very poorly. I believe one of the basic issues with performance is with the overall design. That’s a problem because then the book is pretty much useless. I suppose to be fair the writer might have been targeting a larger audience and not just gamers. WM_PAINT posted messages are done. That’s slow. No respecting game engine will post paint messages, they will gain full control over rendering the window or full screen and "talk" directly to the Direct 3D device interface.
- (This one is personal) I do not like the coding style. Also, anytime a C++ programmer use "this->" the "this" pointer within the object itself doesn’t fully understand that you don’t need to fully qualify the pointer.

If you’re looking for decent code with somewhat decent comments then save yourself some money and just download the DirectX SDK. In it, you will get many examples of UI things. Microsoft created a CustomUI application which runs very, very fast and handles GUI things very similarly to this book. But Microsoft’s runs much faster. The problem with that is you won’t find a very detailed writeup on "why" things are done the way they are. At least I haven’t found it.

Delivers what it promises

I see from prior reviews of this book that there are very mixed opinions regarding it. Its focus is quite narrow: it is only concerned with graphical user interfaces driven by DX9. As such it has no interest in the 3D capabilities of Direct3D, some interest in DirectInput and DirectShow but no real interest in the other DirectX APIs. A late beginner/early intermediate knowledge of C++ is assumed.

An approach is taken of writing wrapper classes for the various DirectX APIs/interfaces and the book is worth purchasing just for its explanation of this methadology. The CD contains projects made in MS VC++ 6.0, but the ones I tried readily ran in MS VC++.NET (the DX SDK must first be installed).

As has been alluded to by previous reviewers, there are some problems with the code in the book. One example is on page 101 where a class constructor calls itself, a very rudimentary mistake guaranteed to crash a program (by causing an infinite loop, assuming the compiler even compiles it). This error is however corrected in the code from the CD.

A more general introduction to the 3D capabilities of DirectX may be found in Frank Luna’s excellent book ’Introduction to 3D Game Programming with DirectX 9.0’. Thorn’s book has a narrower focus, and covers the concepts of interface (graphical, not COM) quite well. It is a useful addition to my small DirectX library and I am pleased that I purchased it.

The chapters are:

1. User interfaces
2. Introducing DirectX
3. Introducing Direct3D
4. Introducing DirectInput
5. Wrapping Direct3D
6. Abstracting DirectInput
7. Beginning CXControl
8. Continuing CXControl
9. Developing Windows
10. Labels and Buttons
11. Text Boxes and Check Boxes
12. Scrolling lists
13. Introducing DirectShow
14. Wrapping DirectShow
15. Building the Media Player

Building a media player using a DX9 interface in the key project followed through the book.

Dissapointing

Being very favourable it could be called a code listing. But the code is incomplete, the naming of the variables and methods seem almost purposefully misleading and the actually logic in some of the code is just off.

Avoid.

Good job at teaching GUI, but code is bad

First off, the book is good at learning how to design a GUI. It goes over all of the necessary information that will let you create a functional GUI.

However, there are problems with this book that others have stated. The code in the book and the code on the CD are VERY different. What you see in the book (screen shots of the examples) is not what you see on your screen when you run the code (the graphics used are very different too). This makes trying to learn some things very hard as you can’t look at the code in the book and compare to it the code on the CD. If you have a question about how or why the code is doing something, a lot of the times, the answer is not in the book because the code is different.

There is also errors with the code on the CD. It compiles and runs, but the textures do not display correctly (they seem to have some wierd scaling going on). A 100x50 texture will not display as 100x50 on your screen using the code in the book, and there is no explaination in the book on how to draw the textures to their scale.

The best way to use this book is to use it as a guide to design your own GUI in your own graphics engine. Just using the UI code provided by the book is not something I would recommend.

I really wanted this book

I read it once and i liked it a lot but then the second time i started Coding along the lines. And i am sorry that i have to say this but the code just doenst work the way its in the book.

The Code on the CD is a bit better but still there are things in that code that just wont let me compile it. I checked the Msdn and everything and its just not right.

I wish this book had a website with corrections because the book itself is good and thats what leads me to write this. I liked reading the book and wanted to program the stuff so bad and so i expected more from the code in it.


I hope this helps

book is exactly what the title says

This book has some good information, but it has a lot of errors also. Some of the code in the book doesn’t work, but the stuff on the CD is fine. I prefer to type it in myself and follow along because I learn a lot more that way. It is impossible with this book because the code in the book and the code on the CD are completely different. It seems that the author changed his mind about halfway through writing the book. This may be the problem for the other reviewers also. It is the reason for my low marks.

I’m not sure why, but it seems every author wants to wrap DirectX with their own set of routines, and this is no exception. I wouldn’t recommend this book if you are trying to learn DirectX, but it has some nice information if you want to build a UI in DirectX.

Nice Class Designs

This book provided me with some great ideas for writing classes.
The authors approach to designing the interface code is easy to understand and read. I will now apply these concepts to my new 3D engine.

"DirectX 9: User Interfaces" provides a solid code base in which one can learn. Note, I said learn-not just copy the code. I’ve been programming in C/C++ for about three years and have read many books. The books alright and worth your time. However, its not for beginners. Many techniques are skimmed over quickly because the author assumes a moderate knowledge base.

In closing I’d like to address the issue of running the programs.
Some reviewers stated that the code does not work. THIS IS NOT TRUE. However, if you attempt to compile the code with Visual C++ 6.0 it will fail. The solution to this problem is to go to the DirectX 9 web site at Microsoft. Next, proceed to the Direct X 9 SDk downloads area. Look for the DirectX 9 SDK Extras download. Inside this download is a set of libraries for the utility features of DirectX 9 that are designed specificly
for Visual C++ 6.0. Set your compiler to these utilities libaries
and everything should work-did for me. If it doesn’t make sure the compiler points to the new lib files before it checks the older ones during linking.

Prior reviews don’t do this book justice

Neither of the prior two reviews should be considered. The one that claims the code is obsolete and non-working simply has no idea what he/she is talking about, and the second reviewer who claims to have a college degree that is somehow supposed to make him an authority says specifically that the code in Chapter 3 on rendering textures doesn’t work.

I just picked up this book, thankfully BEFORE having read those two reviews, and I can tell you that the code worked just fine. Point, Click, Compile, Run.

No errors, no tweaks to get something working.

The book is undoubtedly for a very limited target audience. It shows you how to build a limited but pretty functional user interface in **duhh** DirectX 9. Not 8, not 7, not DirectDraw, not GDI or GDI+. The title is very clear, the author is very clear. If you load the code and can’t get it to work, you’ve done something wrong on your end.

Yes, there are shoddy books out there that deserve to be tossed in the fireplace. But to write a poor review claiming non-functional code when in fact the problem is on your end is inexcusable.

This book teaches what it claims. It gives examples of the topics he covers, and the examples work. Some aren’t all that glamorous, some are in my opinion oversimplified. But the code is good, and the author did a commendable job.