Terrain rendering algorithms comparison

Anybody have any opinions on modern terrain rendering algorithms? Which algorithms seem to be the most prevalent in modern 3D games?

Anybody know of a good source of information on terrain rendering, such as a website with comparisons of different algorithms’ performance?

Thanks

Actually, the brute force method using VBOs and some kind of limited patch culling is today maybe the best one of them all, todays modern harware can push lots of polys.

Well, there’s the world famous www.vterrain.org which is a personal favorite of mine.

Right now, it seems that the tiling methods end up fitting the current hardware pretty well, methods that basically chunk up the terrain into batch-able tiles that can be efficiently streamed to the GPU. Look for “chunked-LOD” or “geo-mipmapping”.

If you can sample textures in your vertex shaders, “clip-mapping” is mighty cool, too. There’s a paper floating around online, and an implementation, I believe, in one of the GPU Gems books (GPU Gems 2).

I probably left something out, but I hope this helps.

(You beat me to it, Zeoverlord :slight_smile: )

Edit: Sorry for the broken link.
Edit: Correction.

Originally posted by zeoverlord:
Actually, the brute force method using VBOs and some kind of limited patch culling is today maybe the best one of them all, todays modern harware can push lots of polys.
I definetly agree with that and I want to point out a similar discussion on beginner’s forum.

Originally posted by Portal:
Right now, it seems that the tiling methods end up fitting the current hardware pretty well, methods that basically chunk up the terrain into batch-able tiles that can be efficiently streamed to the GPU. Look for “chunked-LOD” or “geo-mipmapping”.
I would point out that geomipmapping, in its purest form (as presented on net) does suffer from several drawbacks.
I would say its only advantage is to be quite trivial to implement - this doesn’t mean it’s bad: it is reasonable for smooth terrains and provides adeguate performance on most cases. A hierarchical version makes it even more powerful.

The problem of geomipmapping is that it’s a DLOD-based system “on reverse”. Instead of tassellating the mesh according to an error-driven method, the method computes the error introduced and “pulls away” the mesh until it becomes unnoticeable.
If there’s high-frequency energy in the terrain signal, geomipmapping will degenerate into brute force with extra fat added as memory waste. This is very unfortunate but after all, you wouldn’t use GPUsort on a 256-entry array wouldn’t you?

Originally posted by Portal:
If you can tap textures in your vertex shaders, “clip-mapping” is mighty cool, too. There’s a paper floating around online, and an implementation, I believe, in one of the GPU Gems books.
Maybe but Hugues Hoppe’s home page has everything you need.
Mental note: you get there by googling for “clipmaps”, “hoppe microsoft” or “hoppe clipmaps”, on first hit!

EDIT: fix link… this is my 600th post!