Rating: 
Summary: great educational tool
Review: I purchased this book as suggested by a friend of mine. I've enjoyed each page, as it really gives a gentle, complete presentation of all the core topics involved in creating todays games. The explanations are really easy to follow, much easier to understand than other books like Real Time Rendering, etc. The book deals basically with code architecture, graphics and AI, with minor sections on APIs, special effects, etc. As a CS student who wanted a textbook-kind of approach, this book certainly does the job. I'd miss some content on alternative platforms (mobile, PDA, etc.) as the approach is mostly PC/console centric, but that's fine with me at least... converting this book's ideas and code into MIDP or mophun should be real easy, as there's relatively little API-dependent code.
Rating:
Summary: a very good survey
Review: If you want to learn all the foundational techniques to game programming, this is *the* book. Not nearly as deep as Real Time Rendering, specific as Game Programming Gems, this book covers a wholly different scenario: imagine you know nothing about game development, and need to get a nice jump-start course that puts you up to speed. This is what this book is all about. I miss a section on game audio, but I guess the twenty-something chapters already in the book are more than enough. I'll use it as the companion textbook in a game programming subject I'm going to be teaching but beware: the book is probably too long and deep for a short course, better suited for a full-year academic program
Rating:
Summary: wow!
Review: the scope of this book is simply appalling: it just covers so much ground. Stay away of you're after an "easy" book that teaches you how to code an FPS in 7 days: this is "core game programming". Everything from portals, ROAM, finite-state machines is covered in detail, making it worth of every single penny you spend. Didn't know who the guy was before, but he definitely knows this stuff well
Rating: 
Summary: Disappointing. A lot of info, but sloppily done
Review: This is an ambitious and expensive book. In my opinion it isn't really worth the cost. I have two major criticisms: first, there is no CD with code samples, and no color plates for showing off graphics. Second, it is *very* poorly edited, and the code formatting is so bad as to be almost unreadable.
For example, on page 576 on reducing texture memory requirements the author talks about how using RGB4 is generally okay if you don't have fine color gradients. This is correct. He then refers to an unnamed figure (which we find on the next page) but swaps the left and right side (presumably) defeating his point. He then later refers to the figure, by number, but with completely incorrect content. The actual picture referred to was apparently removed, and the wrong one got its number. This is not an isolated incident. Page 329 has a nasty (yet typical for integer divides) off-by-one error.
Further, I find he often uses pseudo-code where you would want details, and real code where you would want pseudo-code. And the coding style used is also poor, especially when one thinks it is meant to be an example to new programmers. Often #define's are written exactly like normal variables and are used when enums would be much better, upper case and lower case are regularly switched when referring to the same variable, long, unreadable, all lowercase variable names are used, constants are not brought out of loops, braces are not matched up, erratic use of whitespace, etc.
I also found discussion often sadly lacking. The book is admittedly already large, but much could be cut out that isn't interesting or germane (e.g. pages of badly formatted code, or mixing force-feedback effects for DirectX which belongs in a DirectX book). For example, in discussing A* searching no mention is made of using pessimistic heuristics, which in practice can dramatically improve performance. In a very brief section of Design Patterns, no discussion is made about why the author thinks its better to subclass strategies rather than use function pointers.
Some statements are just wrong: "As anyone familiar with algorithm theory knows, sorting a list of N numbers needs at most N log N comparisons, and no algorithm can perform better than that (in a worst case scenario)." Well, in fact, if you can meet certain criteria, you *can* sort in O(N) time (even in the worst case), and many "standard" algorithms require N*N comparisons in the worst case.
There are some good points. The history of games was quite interesting, as was the review of tiling, sprite, and palette techniques. And, if you're a complete beginner to programming, there's a fair bit of useful information, and I'd give the book 3 stars instead of two. Even experienced game programmers will probably learn something, or at least be pushed in that direction. The explanation of BSPs was quite good, for example.All in all, disappointing. For reference, I've programmed the PlayStation (one) for Electronic Arts, and more recently done gaming stuff for mobile phones, and have a background and interest in gaming, 3D graphics, and AI.
Rating: 
Summary: good for general information
Review: This text is an intriguing kind of beast. It gives broad overviews of almost every area that impinges on game engine design, but yet avoids a lot of low level detail in maths and code that one has come to expect - perhaps wrongly? The result is that you can read this book and speak at a very high level, very comprehensively, about myriad issues affecting 3D game engine design - wihout being able to write a line of code. Yes, one could be very cynical about this style of presentation but one has to start somewhere on the learning curve. Along this dimension therefore the book is an excellent conceptual text for students. It reminds me a little in passing of the excellent Turing Omnibus but without the same algebraic grittiness. It is a book to read before reading, say, the two volume Watt and Policarpo or Eberly's book. There is no doubt that for the student who wants a clear overview of the major current issues in game design, without the whole panopoly of algorithms, this is the best text available. Whether the book would lead you into significant coding projects on its own, is a moot question. My personal opinion is that it wouldn't - unless you are already very familiar with the algorithmic implementations required. An ancilliary text with more DirectX or OpenGl meat would be necessary. Setting that judgement aside for the moment, it is an excellent text for anyone requiring an academically informed critique of the many design issues in game programming. Moreover it is also written to be read - a rarity in CS books these days.
Rating:
Summary: Broad approach but well worth reading
Review: This text is an intriguing kind of beast. It gives broad overviews of almost every area that impinges on game engine design, but yet avoids a lot of low level detail in maths and code that one has come to expect - perhaps wrongly? The result is that you can read this book and speak at a very high level, very comprehensively, about myriad issues affecting 3D game engine design - wihout being able to write a line of code. Yes, one could be very cynical about this style of presentation but one has to start somewhere on the learning curve. Along this dimension therefore the book is an excellent conceptual text for students. It reminds me a little in passing of the excellent Turing Omnibus but without the same algebraic grittiness. It is a book to read before reading, say, the two volume Watt and Policarpo or Eberly's book. There is no doubt that for the student who wants a clear overview of the major current issues in game design, without the whole panopoly of algorithms, this is the best text available. Whether the book would lead you into significant coding projects on its own, is a moot question. My personal opinion is that it wouldn't - unless you are already very familiar with the algorithmic implementations required. An ancilliary text with more DirectX or OpenGl meat would be necessary. Setting that judgement aside for the moment, it is an excellent text for anyone requiring an academically informed critique of the many design issues in game programming. Moreover it is also written to be read - a rarity in CS books these days.
|
