Customer Reviews

Core Techniques and Algorithms in Game Programming

5 star:		(11)
4 star:		(1)
3 star:		(2)
2 star:		(4)
1 star:		(0)

 

 

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.

I have just finished using this book as a textbook for our computer game development course at the University of Otago. The text covers almost all of the important areas that need to be mentioned when discussing the development of computer games(audio and physics are a bit thin). When looking for a textbook for this course I compared several other titles including "Tricks of the Windows Game Programming Gurus" by La Mothe. The problems with La Mothe is the writing style and the heavy reliance on API specific code. Sanchez-Crespo avoids these problems by explaining ideas in a clear and concise fashion. By intentionally focusing of the ideas behind the algorithm Sanchez-Crespo has created a book that has a self life beyond most of the current stock of books. If you found La Mothe hard to stomach because of the writing you will be pleasantly surprised with this text.

The text does not provide cookie cutter code samples that make it impossible to set assignments or learn by implementation, but instead provides the background knowledge required for successful application.

I would recommend this text for any student interested in understanding the breadth of knowledge required to be a good game programmer. The feedback from the students in the course was that this was one of the best textbooks they had used for any of their courses. If you are a Professor who needs a text for your senior level University course, I would suggest that they would be hard pressed to find a better text than this.(I know I've tried)

Simon

Being a professor myself, i approached Sanchez-Crespo's book with skepticism. The NRG series is new, the author is an academic and, on top of that, the book does not come with a CD. Still, much to my surprise I have to say this book is exactly what I was looking for. After reading it (and re-reading some passages) the difference with other books on games is appalling: this is a course on games programming, a tool for those who want a formal, well laid-out introduction, that covers all the main topics and leaves few questions unanswered.

The book is structured in two parts: the first deals with gameplay programming, that is, software architecture, artificial intelligence, networks, input handling, etc. The section on AI is one of the best I've seen, and especially the chapter on Scripting Techniques is superb. Both traditional script languages, Lua and Java are covered with detail, so you can get down coding right after leaving the book. Lots of interesting techniques are detailed, such as Djikstra's, A*, etc. so this book is one of the rare instances of AI material designed specifically for games.

Then, the technology section is just appalling in scope: approx. 400 pages full of algorithms, starting with simple 3D pipelines, and then indoors/outdoors rendering, character animation, cameras, texturing, lighting, shaders, etc. The book is surprisingly up-to-date, making me guess the author is a graphics programmer at the core. The shader section is based on Cg, and covers topics such as skeletal animation on shaders, BDRFs, toon rendering, etc. So in the end this doesn't feel much as an introductory book, but as a complete volume of knowledge, ranging from the very basic to the very advanced.

Finally, there's a couple chapters worth mentioning: one on optimization, which is always handy, and another on APIs, which gives all the basic info about OpenGL and DirectX 9 to start coding. The approach for the whole book is not based on specific APIs, but on the algorithms instead. Then, these appendices tell you how to actually translate that into lines of running code.

Overall, my only criticism is that the book could have been longer (physics and audio are not there), and I hope to get a second, expanded edition soon, with more of the same, which is not necessarily a bad thing here.

I'll use it for my students.

Aspiring game programmers face a major challenge. There are plenty of good introductory books out there that will teach them enough to put together a basic game. Unfortunately, the leap from there to being able to program something approaching a commercial game is huge. There are articles and resources covering more advanced topics, but most of them assume a knowledge of several other topics that the reader may have never even heard of before.

That's where this book comes in. Core Techniques & Algorithms in Game Programming provides an excellent survey of the most important topics in game programming and serves as a glue between beginning and advanced texts.

The topics covered include architectural issues such as game organization, data structures, and design patterns, over 100 pages of artificial intelliegence, scripting, networking, occlusion and LOD algorithms for both indoor and outdoor environments, animation and cinematography, shading (including BRDF, lightmapping, and NPR), organic rendering (trees, grass, oceans, clouds), particle systems (including useful performance tips), geometric algorithms, shaders, and an excellent appendix covering performance tuning. Each chapter also includes a list of resources that can be used for further study.

Each topic is covered in enough depth to give the reader a solid, clear understanding of each algorithm or technique without getting bogged down in details. The amount of code listed is limited (but useful), but any decent programmer should be able to easily take the techiniques described in the book and implement them in their language/API of choice. The book moves along at an brisk pace without giving a sense that any topic is being glossed over.

There are only a couple of minor negative points worth mentioning. The first is that there were a few topics (such as some of the basic 2D and 3D sections and the appendices covering Direct3D and OpenGL) that are covered quite well in most introductory books that could have been dropped to make room for other things. The second is that there were a couple of topics that could have used a bit more coverage. There's so much good information, though, that these shortcomings are easily overlooked.

This is one of the most important game development books to come out in the past several years. For new game programmers, it's a must-have. Even experienced game programmers may find this useful to fill in holes in their knowledge. I highly recommend adding this book to your library.

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

Having read many books on game programming, this has to be one of the most "encyclopedic" efforts that come to my mind. There's literally hundreds of algorithms here. I wish it had contained a bit more material on stuff like shaders or HLSL (most of the examples are on Cg), but overall this book delivers what it's supposed to: core material all game developers should know.

The first section (gameplay programming) is maybe the one you'll be less familiar with, as books on technology are way more popular than game logic or AI texts. There's a very good chapter on scripting, and another interesting piece on networked games (this one could have been a bit longer). The section on AI is then the most complete: 4 chapters, covering all the basics and many clever tricks. Then the section on technology is just what you'll be waiting for: a long compilation of the most commonly used algorithms out there, including animation, indoors/outdoors renderers, etc.

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

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.

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 AP

I got this book around Xmas and haven't yet finished reading it, but so far I'm extremely happy with my purchase: the contents are extremely up-to-date, and the explanations are kept simple, friendly. I've been using books like Real Time Rendering for a while, but these are more "reference" texts... Core Tech & Algorithms is a 900-page textbook, and its goal is clearly to help you understand techniques, not to try to squeeze as many techniques as possible in the smallest space.

Still, the book delivers complete tutorials on all of today's general algorithms (portals, BSPs, IK, it's all here), and many all-time classics (from Atari to Zelda, etc.). I'd recommend it to people who'd like a textbook-tutorial approach: you'll understand each and every technique Mr. Sanchez teaches here. I wish the book was longer, and more techniques were added in... a chapter on Audio and another on Physics seem somewhat lacking to me.