Customer Reviews

Focus On 3D Terrain Programming (Game Development)

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

 

 

The text doesn't come close to describing any of the terrain rendering algorithms adequately. For this, the author refers the reader to whitepapers on the companion CD written by the original authors. After a short search on the Internet, I turned up a wealth of better written descriptions on 3d terrain rendering algorithms. I suggest others to do the same.

The author makes a big deal out of the importance of morphing vertex points to minimize the effect of popping but provides no implementation description. As he says in the text: "I didn't want to limit your imagination..." What a cop out!

The c++ code provided on the companion CD is cleanly written, compiled and ran without problems, but is also clean of any useful comments further mystifying the subject. Another search on the Internet turned up many source code examples with better documentation.

Wow. Let me just start off with that. I started this book with very little understanding of terrain algorithms. Now I know 4 major approaches to terrain and how to implement them, with many different possibilities for texturing, lighting and culling. If you are a beginner in the world of 3D terrain, then this book is the best one you can have right now. It can take you from a complete beginner with some basic openGL knowledge, like I was, to someone who knows how to write a very effective 3D terrain engine.

This book is NOT for advanced 3D terrain programmers. It will be very useful to a beginner, like I was. If you know how to do 4 chapters' worth of this book- the basics and one of the more advanced algorithms- then it's not worth it. If you know any less, I'd strongly recommend it! It teaches the main algorithms that have stood the test of time in 3D Terrain Programming, and ONE NEW ALGORITHM THAT'S SO CUTTING EDGE, IT HASN'T EVEN BEEN OFFICIALLY PUBLISHED YET- ROAM 2.O, the next iteration of possibly the most major CLOD algorithm yet developed!

Here are the contents:
Introduction
Ch2. Fractal Terrain Generation, Heightmap Loading/Unloading, building a base terrain class and a Brute Force implementation.
Ch3. Texture mapping, procedural texture generation, and detail texture mapping.
Ch4. Height-based lighting, hardware lighting and when you shouldn't use it on terrain (too much normal recalculation in CLOD), lightmapping and slope lighting.

The three major CLOD algorithms:
Ch5. Geomipmapping theory and implementation.
Ch6. Quadtree theory and implementation.
Ch7. ROAM, improvements to ROAM, new ROAM theory and the implementation of ROAM 2.0- the latest in CLOD.

This book culls together information that is scattered over the web, various books and conference articles into 203 pages of very useful information. It teaches you 4 major approaches to terrain: brute force, the initial algorithm for all developers, and 3 advanced Continuous Level Of Detail algorithms. A beginner would spend a month, easily, finding all of the resources to learn this material. Then when you want a quick reference, you have to rehunt for all of this material, which can waste a half hour or an hour. I read this book in 3 days. Whenever I want a quick reference, I grab it off the desk next to my computer. You be the judge.

This is an excellent book, well worth purchasing if you're interested in terrain rendering and don't have a good idea where to start, or have never coded a terrain engine before.

It starts out with simple explanations of the basics of terrain rendering. Many of you will probably be familiar with the techniques in the first portion of the book.

The meat of the book, however, evaluates ,in a non biased fashion, three different CLOD algorithms. Along with the whitepapers included on the CD after reading this book, you should have a throuough understanding of how to implement these algorithms yourself.

The code included on the CD is well written, and very concise. If you're a hardcore C++ programmer, you may be irked by the lack of fancy template usage, or C++ streams; but the way the author has structured everything makes it very easy to understand the code whether you are familiar with C or C++.

The last chapter is a nice add-on. If you are familiar with techniques such as sky-boxes and particle engines, you probably won't find it very useful, but for the uninitiated it could prove to be quite useful.

What this book will not teach you, however, is API specific details. It assumes you are comfortable using your API of choice. It will not teach you any 3D math either. You should be fairly comfortable with matrix and vector operations/basic linear algebra before attempting to code the algorithms discussed in the book.

It's not a book for the graphically-uninitiated, but if you're allready familiar with either Direct3D, or OpenGL and you understand some basic 3D math (rotation and scaling with matrices, vector normals and such) it's an excellent book, well suited for teaching you terrain rendering.

In my previous reviews of Premier (formerly Prima) Press' titles in their Game Development Series, I had one chief complaint - the size of the books. The books often covered rather narrow subjects, but they were padded to enormous size with a lot of "extras" that have already been better covered in other books. Hence the series consisted largely of 700-page books that retailed for as much as $60. This can certainly be forgiven for a title that covers a broad subject like <i>OpenGL Game Programming</i>, but you just know that a 700-page book on writing isometric-perspective games is doing a lot of padding.

Thankfully, Premier has addressed my concerns with their new "Focus On" series. This is a sub-series of books that better fit the narrow subjects to which they're written, both in page-count and price. They average 200 pages and cost around $30, which makes the purchasing decision much less stressful, at least for me.

<i>Focus on 3D Terrain Programming</i> is a good example of the series. It's a fairly narrow topic and is sized and priced accordingly. It doesn't pretend to be a DirectX tutorial or a tutorial of any kind, for that matter. It's a book on how to draw, light, and walk realistic-looking 3D terrain, and that's it. It predictably starts off with the simple stuff, drawing a 3D mesh from a heightmap. Chapters 3-4 cover texturing and lighting terrains realistically. Chapters 5-7 cover more advanced algorithms like ROAM, which was used for the game Treadmarks, a game for which the author has a significant soft spot. The algorithms are well-illustrated and easy to follow, even for an old die-hard 2D curmudgeon like myself.

Further kudos to the author for actually explaining the algorithms rather than just pasting in ten pages of example source code. When explaining how something abstract like a code algorithm works, a picture truly is worth a thousand words. Too many books (including many Premier titles) take the easy way out by just posting a bunch of code and hoping that the reader can figure out the technique. <i>Focus on 3D Terrain Programming</i> is thankfully light on pasted-in code and heavy on explanation.

The pack-in CD is also quite good, containing all of the code examples along with executable versions of all of the examples so that you can see an example work without having to drag out your compiler. I've got too many books where the CD includes all of the example source code, but for some reason fails to include the executables or, in some cases, the project files.

In the way of complaints, I have to cite the author's age. While I was hoping not to need to point out that the book was written by a high-school kid, the repeated use of "cool" and "awesome" in describing virtually everything makes it hard not to. Also, while the book covers several terrain algorithms, some are just mentioned by name. A couple are covered in third-party articles on the CD, but some weren't. Finally, somebody didn't take a very close look at how the some of the pictures would look in black & white, because many of the photos of example textures just look like burnt mud.

And a final note. All of the examples are done using OpenGL. While I find this an understandable choice, given that it at least gives the appearance of being cross-platform, some may have preferred Direct3D examples. Far as I can tell, the author's not using any OpenGL features that are so advanced that they couldn't be done as well with Direct3D.

In conclusion, Premier finally stopped trying to make all of the books in their Game Development Series be all things to all people. Books like <i>Focus on 3D Terrain Programming</i> that cover a single subject are given the small and inexpensive treatment they deserve. It's not a perfect book, but if you have a need to draw 3D terrain in your game, it's a good place to go.

The book begins with approximately 100 pages of the extreme basics of terrain rendering. Given this speed of progression, such an introduction would be proper to a 500-600 page text. However, the author then covers three LOD algorithms in approximately 80 pages (the final 20-30 pages are devoted to special effects).

Unfortunately, all Polack's work serves to do is provide a lackluster (and often bastardized) summary of freely distributed whitepapers covering the discussed algorithms (included in the text's accompanying CD). His youth and inexperience as an author are blindingly apparent, as his "hip" talk quickly becomes both an annoyance and a distraction. The most advanced mathematics covered in the text is essentially no more than arithmetic. When Polack does attempt to explain math (which is not very frequently), his descriptions are nonsensical and often incorrect. For instance, in chapter 5 he covers the distance formula (this Jr. High math is among his most advanced formulae). He then proceeds to give an equation called "L2-Norm" which he states "Isn't that much different than the distance equation from chapter 5. The only real difference is we're not bothering to square the individual component calculations, and we're saving ourselves the trouble of a square root. Other than that, not much has changed". If Mr. Polack was at all familiar with the methods of mathematics, he would comprehend the huge implications of removing the squaring in the distance equation - unfortunately he is not, and he gives no further explanation as to the consequence and reasons behind using "L2-Norm".

Computer graphics is a subject based upon (often complex) mathematical operations. Polack has, however, decided that instead of "boring" the reader with a description of math, that he will instead make jokes in regard to an "imaginary cat" among other things. The first 100 pages of the book are a simple introduction to terrain rendering, which is why I give this book 2 stars. The remainder of the book is indeed the work of an inept author struggling to make sense of complicated topics. I would most definitely NOT recommend this book.

A note to the author: once you have learned to appreciate the art of high-level mathematics, perhaps attempt to rewrite this book, yet forego your childish style and elaborate on the algorithms at use (do not attempt to write a text on terrain rendering in a month, as it seems you have done). It is truly unfortunate that the shelves of bookstores are being taken by books such as these, whereas masterpieces such as those written by Watt, Moller, Haines, Abrash, and Foley are pushed aside.

I think many of the reviews here are a bit harsh and miss the intention of this book. The chief complaint of the book is that it does not go into very much detail. It seems to me that this title is intended to be a basic introduction to what is a very complex topic.

Having developed terrain applications for many years, I have a very thorough understanding of how difficult it is to approach this topic. While there are many great books available on the topic that go into much greater and complex detail (see: Musgrave, Perlin, Foley, et al), there has long been a need for a simple, basic introductory text.

This book fills that need.

Rather than inundate the new reader with 1000+ pages of difficult material, Polack gently takes them through the basics of terrain rendering. Using humor (which really isn't as bad as some stuffed shirts would have you believe), he gives good, basic explanations. The accompanying CD contains a lot of good source code, ripe for exploration. An excellent way to learn. For those who haven't been scared off, the original white papers are included for further studying. Polack also includes chapter-by-chapter references for additional reading.

The complaints over the fact that the book uses OpenGL are also a bit silly. The important thing here are the topics and the introduction to their basic principals. Also, OpenGL is more universal than DirectX, giving this book a broader audience. If the need to use DirectX is such a concern, you can always write your own rendering and buffering adapter.

All in all, I heartily recommend this book for anyone interested in getting a start in terrain modelling. Ah, if only it existed when I started out with Musgrave's Texturing and Modeling book! ;)

After programming for quite a few years, naturally the topic of terrain rendering came upon me eventually. Before reading this book, I had researched every LOD algorithm covered in the book; however, what makes this book great is the ease at which the algorithms are described, thus making implementation all the more simpler. While covering several tessellation algorithms, the book extends its literature by discussing and providing much sample source code for great effects that many beginners would be lost in understanding of, such as liquid simulation, terrain lighting and texturing, sky domes, etc. Although, the book certainly isn't for the fairly advanced graphics programmers, it's great for an aspiring coder.

I consider that book an outrage. His writing style is disgusting. Also, if the author does not know anything about mathematics, why did he write a book like this one? He covers 3 algorithms about terrain, but this topic is much more complex than that! I have read more than 30 articles about other terrain algorithms, including those 3, and they are all much better explained. The ROAM 2.0 algorithm is very bad-explained, I had to understand it by other means.
A complete useless book. Although the young author really has a good future, I don't understand how a teenager was allowed to write this kind of book.

Let me first state that I am a big fan in general of the entire game development series. They have all been invaluable as a resource for reference and for building a general knowledge base in each topic they cover. This book is the same EXCEPT that it offers NOTHING new or valuable to any accomplished or budding OpenGL programmer that they cannot find at gametutorials.com or nehe.gamedev.net. There is literally nothing in this book that is not covered at gametutorials.com as a free download in the tutorials or code dump section. Buy it if you dont have about 30 minutes and a decent bandwidth to download the stuff for free. The explanations in the tutorials at the sites listed above are much more helpful than those provided in the book.

BIG CONS:

1>The 3D math explanations for the topics covered are non-existent this highschool student must be a bright kid, but he is no author.
2>You can get the code for free elsewhere.
3>NO and I mean NO explanation of the use of any sort of USGS data or how to apply it to any of the big 3 algorithms covered in the book. How can any book on 3D terrain programming not cover the use of real world data?
4>The price seems right until you pull it out of the box and it is the size of an old Archie pocket comic.

I was very disappointed. It should have been called "Focus on page 4 of gametutorials.com. OpenGL tutorials".

You have been warned.

First of all, Polack's writing style is very annoying. He tries to make his writing "hip" by randomly adding in references to pop culture. It just doesn't work. It makes the book harder to read. At worst, his style is insulting.

Style aside, the content of the book is not bad. It shows you the main concepts in terrain rendering. Three popular Level of Detail algo's are presented: ROAM, Geomipmapping, and quadtree rendering. The implementation details are pretty much left to the reader (or you can read his code in the CD-ROM). You WILL have to read the terrain whitepapers and understand them (also on the CD).

The book is basically for the person who knows a bit about gfx programming (OpenGL, Direct3D, or whatever) and wants to get his/her feet wet in terrain rendering.

If you have already read the geomipmapping whitepaper and understand its concept, you will find this book useless.