Haxpor

That’s it for the declaration.

In other cases that you use your own vertex-declaration, make sure to define it correctly according to your apps. Plan each vertice to have what characteristics is the crucial part and very important process before you begin any furthur actions. This can save time for you later on.
(for these reason I put this topic first before we start the less ;) )

Local Variables
Graphics device and effect
Now I will show you the variables need for this Terrain class.
What we need in the first place is these.

1
2

GraphicsDevice device;
Effect effect;

Above for both device, and effect will be sent from the caller who create Terrain class. Normally they will be sent from Game1.cs file. (Initially they exist there at the very first time if you didn’t modify anything.)

Heightmap
Next we need heightmap (the map in which it contain the height data of each position in the terrain, so in this case we can let the artist do it for us or even tell them that we want the mountain!!!) to be used for our
terrain, note that it defines the environment appearance as the black area is lower, the white area is higher, this is becase white-color is 255 but black-color value is 0, so we use this data and tell the artist to create the mountain or even you can imagine for terrain-generation.

Sample heightmap is

Sample heightmap

This let us to define the following line,

1

Texture2D heightMap;

Vertices
See below,

1
2
3

MultitexturedVertex[] vertices;
short[] indices;
float[,] terrainHeightData;

Above is must like the vertices’ architecture.
We must keep all terrain’s vertices. Also we keep the information of each vertice’s height.
Note that we use the indice to hold which vertice is in what position, such as defining them in clockwise or counter-clockwise (according to what rule you use, left or right hand rule => to define such vertice for each polygon), indice also plays the important role here as it will minimize our vertice declaration to only one vertice for one declaration, thus we can reuse it for generate another polygon for our terrain.

If you confuse about the left, right hand rule or using the indice for defining the vertice for such polygon, you should read this for the real in-action of the purpose of indice.

Terrain width and height (non and scaled value)
See below,

1
2
3
4
5
6
7
8
9

        //Actual non-scaled terrain width
        int terrainWidth;
        //Actual non-scaled terrain height
        int terrainHeight;
 
        float minHeight;
        float maxHeight;
        float scaledWidth = 1.0f;   //default
        float scaledHeight = 1.0f;  //default

As you see above, I have 2 version of width and height, that’re non-scale width and height, and another version is scaled width and height.
The reason for this is, I want to scale my terrain in the x-direction (its width, not its height) as far as I want, so my terrain will look large enough and suit my apps.
You can set the scale-multiplier for both x, and y-direction to suit your need.

Warning: Not recommend to change the scaledHeight, you should leave it as 1.0f unless you know what’re you doing.

The min and max hieght are used for information-purpose only. They are both automatically assigned the value when we create the terrain. So you will know your terrain’s min and max height.

4 Textures
Now it’s about the textures being used in the procedural method of generating terrain.

1
2
3
4

        Texture2D sandTexture;
        Texture2D grassTexture;
        Texture2D rockTexture;
        Texture2D snowTexture;

I will use 4 different textures for the terrain, its used will depend on each vertice’s height.
As you may suggest, the lowest of the terrain will use sandTexture, above this level will use grassTexture, and so on. So at the very top you will see the snowTexture. It makes sense right?

The textures are below (included in the project file, show here for consistent)
- sand texture
- grass texture
- rock texture
- snow texture

Buffers
We use buffer to hold the vertices-data and send it to GPU and draw it.
It ranges from VertexBuffer which hold the vertices data.
IndexBuffer, as you know about indice, this’s for.
VertexDeclaration, it define the vertice, as you already know from the very top of this post about the vertex-delcaration.

See the declaration below,

1
2
3

        VertexBuffer vertexBuffer;
        IndexBuffer indexBuffer;
        VertexDeclaration vertexDeclaration;

The less
The less is for the world matrix for the terrain, if you want to adjust its position and rotation (which is less lightly to do because it uses much more of cpu time and waste cycle) but for my apps I personally like to adjust it just for learning :) , and combined with the light and effect setting for this terrain.

You will know all about the LightSettings and EffectSettings class in the next appropriate subtopic. For the generating of terrain, they are not that important to know at this time.

Next post, I will show you the real implementation, that’s methods inside the Terrain class. I insist not to go furthur because the post will go too long, I think I should split it a little. See you next post about all of these Terrain stuff.