Question

I’m trying to create tiled terrain in 3D with XNA. I checked tutorials on how to do
it(Riemers and Allens). Allens tutorial has an exact result I want to achieve,
however I’m not sure about performance – it seems he is using single quadrilateral to draw
all terrain and process it with pixel shader, it means – whole terrain will be
processed each frame.
Currently I’m drawing a quadrilateral for each tile(Example) – it allows to draw
visible tiles only, but it also means that much more verticies need to be processed in each
frame and a lot of “DrawIndexedPrimitives” is called.
Am I doing it right or Allens way is faster? Is there a way to do tiled terrain better?
Thanks.

Answer 1

Totally depends on your terrain complexity and size. Typically, you will have terrain tiles with more than one quad/tile (for instance, a tile could consist of 4096 triangles) and then displace the vertices to get the terrain you want. Still, each tile will be a indexed primitive, but a single draw call will result in lots of triangles and a larger part of the terrain. Taking this idea further, you can make the tiles in the distance larger so you don’t get too much detail (look for quad-tree/clipmap based terrain approaches; you’ll get something like this: http://twitpic.com/89y5kn.)

Alternatively, if you can displace in the vertex shader, you can use instancing to further reduce the amount of draw calls. Per-instance, you pass the UV coordinates into your heighfield and the world-space position and then you again render high-resolution tiles, but now you may wind up with a single draw call for the whole terrain.

For a small game, you might want to generate only a few high-resolution tiles (65k triangles or so) and then frustum-cull them. That gives you a large terrain easily and is still manageable; but this definitely doesn’t scale too well 🙂 Depends on your needs.

For the texture tiles, you can also use a low-resolution index texture and do the lookup into an atlas per-pixel or just store the indices in the vertex buffer and interpolate them (this is very common: Store 4 weights per vertex and use it to look up into four different textures.)