Customer Reviews

Inside Direct3D (Dv-Mps Inside)

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

 

 

If you are very new to the Direct3D Immediate Mode API and don't feel like wading through the SDK documentation, by all means buy this book. On the same token, if you don't feel like wading through the SDK docs, don't even bother trying to learn Direct3D. "Inside Direct3D" is a summation of the material presented in the Direct3D documentation, nothing more, nothing less. If you're looking for advanced techniques, please don't waste your money.

Pros:

1) The examples actually work and are easy to install!

2) If you've ever read any of Kovach's other books, well... the code isn't AS bad as before.

3) It'll get you on your way if you understand 3D graphics concepts and C++.

Cons:

1) for only the cost of paper and ink (and some staples), you could print out the DirectX documentation and get the same effect.

2) two entire chapters are devoted to non-Direct3D material (DInput and DPlay). The time and effort spent rehashing material from "Inside DirectX" (1998) would have been much better spent expanding on the bare-bones coverage of some topics.

Summary: A good starting book for people who don't have the patience to experiment alot. Beyond the basics, though, don't expect alot. If you have any questions about this review, feel free: (donniedeboer@hotmail.com)

First of all, let me say up front that this book is *far* better than the author's previous Direct3D work, entitled "The Awesome Power of DirectX/Direct3D". Anyone interested in why I would mention this should look at the customer reviews for that title. I just want to make sure no one who gave up on the earlier book is scared off from this one just because the author is the same. Whether the improvement is due to Kovach's having more time to complete this one or because of better editing from the Microsoft press folks I don't know, but suffice it to say that this one stands far above the earlier work.

What also makes this book a definite improvement is the fact that it's the first one in the market to deal with Direct3D Immediate Mode. The coverage of Immediate Mode is fairly detailed, although sometimes the author doesn't explain his code snippets in enough depth, leaving the reader to try and figure out what's going on. It's not done to an unforgivable extent, but it can be annoying at times.

If you're new to Windows programming in general, or unfamiliar with 3D concepts and basic linear algebra, you'll also need a companion book to really understand some of the discussions, because the goal of this work is to demonstrate how to use Direct3D's API to create interesting programs. It's not that the author ignores beginning users, but his goal is to focus on what Direct3D (and friends) can do for your programs, and 450 pages only gives you so much room to work with.

His coverage of Direct3D topics is pretty comprehensive, with texturing, stenciling, T&L issues and others all getting a fair shake. He also includes some interesting software which will allow users to load Quake2 and 3D studio models into your programs. Code for doing so is included on the companion CD.

In short, this is a good book for anyone even remotely familiar with Windows programming, DirectX and 3D theory and concepts. When you consider the other Direct3D books on the market, this one looks even better.

The book fails to provide necessary concepts enough to understand programming in 3D. The concept is there, but the explanation is often too short and brief. You'll need to dig up many other 3D computer graphics books just to understand various terminologies and concepts. Unfortunately, exact same thing happens when it comes to covering Direct3D. It lacks significant amount of explanation on various Direct3D Immediate Mode functions. Often times you will find yourself browsing through DirectX help files to find what individual functions do, only to find out Microsoft's own help files too lacks a good explanation on what that function/member of a structure do.

Come on guys! We're talking about programming 3D application using Direct3D Immediate Mode, by far the most complicated subject when it comes to Windows programming, and mere 300 pages is not going to cut it.

I also find that a lot of texts on Direct3D Immediate Mode in this book is a direct (or indirect on some) copy from DirectX SDK Documentation.

This book definitely missed a target. Save yourself. Dig through Microsoft's SDK Documentation and its sample codes until a real, definite Direct3D tutorial book for a beginner comes along.

For what the book is trying do, it does well. It covers all aspects of Immediate mode, including some of the more obscure stuff. When I first read the book, I was a little disappointed because the text feels a little watered down. Then I started looking at the source code for each chapter and it helps explain each chapter's focus. Also, the book is on how to use the Direct3D API and as such assumes the reader already knows (or can learn elsewhere) basic 3d concepts, math, algorithms.. All in all, a good book for someone who wants to learn the d3d api in detail without getting bogged down learning wrappers, etc.. that seem to abound in other texts.

A word of warning to those who are unfamiliar with transformation and vector math: this book won't help you with these. It will, however, give you a complete, yet compact, tutorial to the overwhelmingly complicated Direct3D. I say compact because the author is light on examples, and heavy on code. This doesn't deter from the learning, it just makes the reader have to read a chapter over and over again. The bottom line on this book is that if you're willing to put in the time and effort, and have references to transformation matricies and vectors handy, you can learn how to program Direct3D.

I'll have to agree with the majority of reviewers in giving this book something less than a passing grade. It is, in large part, a rehash of the Direct3D help files, although with better explanations thrown in.

Don't look for any in-depth explanations on general 3D theory or graphics concepts here-- topics such as alpha blending, fog or texturing get a quick overview, followed by a lengthier discussion on how to use Direct3D to achieve these effects. And that's as it should be; after all, the title of the book is "Inside Direct3D", not "Inside 3D". You can only cover so much ground in 400 pages.

However, even the Direct3D-only discussions need a lot of work at times. As I mentioned, they're often just a rehash of the help files, with a lot of macros and constants tossed about, but with a less than perfect explanation as to what they refer to. When you have a bunch of variables bandied about in code with no context explaining where they came from or what they do, it's easy to lose track of what's what.

The first 100 pages of the book were, to me, almost incomprehensible at times. Kovach uses these pages just to explain how to setup a Direct3D application, and the code in there is bewildering. To be fair, setting up Direct3D can be *very* convoluted, and he's using Microsoft's code in those pages, so the lion's share of the credit/blame falls to them. And if you can get past those first pages, the rest of the book is a good deal better, but still has rough patches at times. The Direct Play/Direct Input chapters come to mind as I write that last sentence.

I'll give Kovach credit for a good try at a difficult subject, and he seems to be the only author out there who's willing to tackle this stuff, but I just can't reccomend the book. It's not his fault that Direct3D is difficult to use-- he just gets a little more of the blame than he should.

When I first purchased this book, I installed the software, only to find that it would not compile after Chapter 3. This was frustrating and very discouraging. After reading the Microsoft technical documentation for Direct7, I learned that you may need to go to Tools->Options->Directories and make sure C:\mssdk\include and C:\mssdk\bin appear at the top of the directory lists there.

Once I got it working, I was impressed with the graphics. If you are focused on writing 3D games for Win32, this book is a good investment. Otherwise, don't bother - read the SDK and use the examples there.

I have to consider the author has made a real effort to bring up some glimpses to program this API. I think the book is good the way it was written, because it explain the basics of Direct3D and gives a fair explanation on how to construct your engine using some nice features from Direct3D, and in a step-by-step manner.

We may notice the first problem with the book on the API itself, because DirectX 7 (and previous versions) was written to give us flexibility, but no way it's easy to use. Microsoft promises that DirectX 8 will be easy play, so if you want to wait a bit more... on the other hand, the book is a bit confusing, especially for the newbies, because the author does consider that the user already know how to program C++ and have a good knowledge on COM and a bit of knowledge on DirectX. I say this because the explanations from chapter one through four are a bit *compact* (let's say this way).

Chapter 5 is fine, but chapter 6 starts again to be confused and poor on explanations. And this continues to go on the rest of the book. I have to say that if i didn't have any previous knowledge on Direct3D i shouldn't understand the some parts of the book.

For someone who is starting now, i recommend reading this book, specially if you are trying to work with microsoft provided framework that makes our lives easier. But *do not* buy this book if you expect to see clarification on WHY things are done - the author just cares about writing HOW they do it, nothing more... the author just rehashed a bunch of Microsoft's SDK Documentation, wrote some progressive examples to make easier to understand and made some comments on each feature.

I also recommend to search over the internet for more tutorials, so the understanding will be easier.

Anyway, it's a fair book, because i haven't seen any good book that the author dares to teach Immediate Mode (remember that Trujillo just talks about Retained Mode) and succeed. The API itself is very hard, and if you expect to domain it you will have to fight hard. Certainly, it isn't "the definitive guide" but surelly it can put you on the right road.

My feeling is that this is most likley the best Direct3D Intermediate Mode book that is currently available. I have doing DirectX Development on and off for a number of years, but this book represents my first real attempt to understand Direct3D Intermediate mode.

The main problem with this book is that the Kovach develops a framework for developing games. He does a poor job at explaining his framework and expanding on Microsoft's SDK documentation. I have to give him credit for having code that actually compiles without hundreads of warning, but their is just two much code for someone who is trying to grasp the basics of Direct3D Intermediate mode.

It is very easy to get lost, since Kovach does not use small, focused, well documentated examples to explain the Direct3D Intermediate mode concepts. Once lost, you will not find the awnsers with the pages of this book, because there is not enough detailed explaination. Cutting-Edge Direct3D Programming does a good job of explaining these concepts for Retained Mode.

In conclusion, get your self familier with the Microsoft SDK Direct3D sample files, and don't expect this book to be your only reference.

First off, yes, you can get all of the information presented here in the DirectX SDK docs. By that argument, you can get whatever information you want from the MSDN Library, so why buy any books at all? The reason is that this book gives a better explanation than the SDK docs, and comes with a sample program that actually works. It goes over enough of the api, and gives you a framework that you can actually go through and build a working program with. I do agree with a couple of the other reviews and question the inclusion of DirectPlay and DirectInput. But because they are there doesn't justify giving this book a lower rating. If you can't get the programs to compile then you need to spend some time learning a little more about your compiler. I bought this book so that I could make a D3D port of my openGL code and was able to easily make the transition thanks to this text.