Landscape Generation

3D Landscape Generation in VRML

Two examples

Mountains
Rivers and lakes

Mountains

Randomly generated surface

Here is an example of 10x10 randomly generated VRML-world using Java.

The textures are important because they can make landscape look far more realistic and hide large and clumpy polygons.
In VRML the node "ElevationGrid" hides the details of building each polygon.

It's a rectangular grid of varying height values.
The input is the dimensions of the quadrangle (xDimension and zDimension), a vector of height values, and the spacing between the adjacent grid nodes.

To build mountains we need to build some profile for the mountains, i.e. how should the hillside look like.
The most simple one we can think of is the following:

Simple linear hillside

A more typical and more stereotyped profile would be a spline profile. When generating such mountain on the fly, i.e. in real-time, it can slow down or stall the virtual world for several seconds.

Spline hillside When we want to build a complete mountain we can add it from the profile generation of heights and randomly generated value to add on it.

Profile and random surface added together

Here is an example of 35x35 landscape with total 1225 height values. Where we use the linear profile to generate the mountains (hills) on the map. The distance from the origin of the mountain to each and every height point on the map is calculated. This distance is then used to determine how high this point should be.

Even though the linear profile is not our typical idea of mountains, it look quite good when combined with the randomly generated surface.

The problem with this demo is that the texture isn't so good and the resolution of the ElevationGrid isn't very high. The texture could for example be rocky and snowy for high mountain tops and green for valleys.

Rivers and Lakes

Texture

Textured river could for example be textured with animated gif-pictures. If the texture is transparent to some degree we are able to have animated fishes and other animals in the water.

Path

First we would like to determine which pathway the stream runs. If we are using system that lets the designer project 2D picture into a 3D landscape, a straightforward way to do it would be by painting as a line on the 2D picture. The problem here is to have it consistent with the slope of the landscape.

There is the danger that the stream will be flowing upwards in several places to be able to run all the way to sea. For example what should happen if the stream runs into a small valley.

There are several possibilities of a solution:

The river ends in the valley and goes into the earth (disappears)
The river flows upward out of the valley
The river generates a lake in the valley and stops there
The river fills up the valley with a lake and then flows out of it

The last option seems to be the most natural one.
Actually it shouldn't be the designers job to decide where the river runs. He should decide where the water comes from, i.e. where the quell is, and then the path is calculated correspondent to the landscape.

If we are using an editor to simulate this, the designer would simply press once with the mouse button somewhere on a mountain and it would automatically draw the path of the river. A good option would be a adjustment of the amount of water, i.e. tons of water per second.

The algorithm to make the path, doesn't have to be complicated. The river simply runs along the junctions of the polygons, and when it comes to a crossing of polygons, it chooses the way where they slope is at most in the downward direction.

If none of the paths between polygons run downwards, obviously we have to make a lake or a puddle there.

As a way to find out how deep the lake should be we have to use a search algorithm on the polygon tree to find a way out of the valley. We start the search where we didn't find a path downwards (the blue spot on the picture below) and go to all the adjacent crossings of polygons. For all the polygons we check we have to record the height of that point and find out whether there is a way out of the valley there.

When we have find a crossing where the water runs out of the lake, we also know how deep the lake will be. Therefore we can easily find out how far the lake has spread itself over the valley.

Sometimes we don't want to fill all valleys that the river encounters, so we could set a maximum depth of the lake. If it reaches this maximum the river stop searching for a way out and simply doesn't run out of the valley. This maximum value could be combined with the adjustable amount of water that comes out of the quell.

Width of the river

The width of the river could be determined in the same way. In this case, we would search out from each node of the pathway to the sides. The search to the sides is not time-consuming because the search tree will not be more complicated than a binary tree.

Here could the depth of the river be in consistency with the amount of water that comes from the quell.

This lecture I have given does not solve all the problems which could occur in this simulation, but to simplify the process I have shortened the lecture to make it more understandable and shorter.

Berlin, 2nd May 1998,

Alfred Hauksson
hauksson@cs.tu-berlin.de

References:

VRML 97:
The Virtual Reality Modelling Language
International Standard ISO/IEC 14772-1:1997