Mogre Basic Tutorial 3         Terrain, Sky, Fog, and the Root object
Tutorial Introduction
Ogre Tutorial Head In this tutorial we will be exploring how to manipulate terrain, sky, and fog in your Mogre applications. After this tutorial you should understand the differences between Skyboxes, Skyplanes, and Skydomes, and be able to use them. You will also know the difference between the different types of fog, and how to use them.


If you find any errors in this tutorial please send a private message to amirabiri.

Prerequisites

  • This tutorial assumes you have knowledge of C# programming and are able to setup and compile a Mogre application.
  • This tutorial also assumes that you have created a project using the Mogre Wiki Tutorial Framework.
  • This tutorial builds on the previous tutorials, and it assumes you have already worked through them.


Getting Started

As with the previous tutorials, we will be using the Mogre Wiki Tutorial Framework as our starting point. We will be adding code to the CreateScene and ChooseSceneManager methods. Add the following code to your tutorial class:

protected override void ChooseSceneManager()
{
}


NOTE: This code won't run yet until we add the right code to the ChooseSceneManager method.

A Note About Paging

Version 1.7 of Ogre introduced a new Terrain component with paging ability (creating big worlds from "tiles" of 3d terrain). Work on introducing this functionality into Mogre is underway as of this writing. However, until this functionality is properly integrated into Mogre and declared stable, this tutorial deals with the old terrain functionality.

The Root Object and SceneManager Creation

Root

In this demo we will be rendering Terrain in Ogre. To do this we need to use the TerrainSceneManager instead of the default one that the the tutorial framework provides for us. Add the following code to your ChooseSceneManager method:

protected override void ChooseSceneManager()
{
    mSceneMgr = mRoot.CreateSceneManager(SceneType.ST_EXTERIOR_CLOSE);
}


The Root object (mRoot is an instance of Root) is the "core" Ogre object. You can see a UML diagram of the relationships between Ogre objects here. You have now seen almost all of these objects in practice, with the exception of the RenderSystem. In this chunk of code, we are telling the Root node that we want a SceneManager of the ST_EXTERIOR_CLOSE type. The Root object then queries the SceneManagerEnumerator to find the SceneManager of the type you requested and returns it.

After your application is set up, you rarely ever have to deal with Ogre's Root object, and you don't ever interact with the SceneManagerEnumerator directly.

SceneManager Creation

There is an important note about SceneManager creation and storage that will save you confusion in the future. SceneManagers are not Singletons. You can create as many of them as you want, and unlike SceneNodes/Lights/etc you can create them directly with a "new SceneManager()" statement (you do not have to use Root's getSceneManager method). You can have multiple SceneManagers populated with multiple separate geometries and entities at the same time. You can swap between any of these at any time by recreating the Viewport (this is covered in Intermediate Tutorial 4) or display multiple SceneManagers at the same time using multiple Viewports.

Why do we use the CreateSceneManager function instead of creating our SceneManager object manually? Well, the plugin system in Ogre gives us a great deal of flexibility when working with single SceneManagers. There are only a few scene types defined in the SceneType enum. Until now, the MogreFramework has been choosing ST_GENERIC as our SceneManager. You might think that this is the base SceneManager class, but as long as you did not fiddle with the plugins.cfg file, then that's not what you have been using! The OctreeSceneManager registers itself as ST_GENERIC and overrides the base SceneManager class if you are using the OctreeSceneManager plugin. The OctreeSceneManager uses a system of culling items that are not actually on the Scene (and thus it's generally faster than the regular SceneManager). If you removed the OctreeSceneManager plugin from your plugins.cfg you would *probably* be using the basic SceneManager when you request ST_GENERIC.

This is pretty neat, but you can run into some problems. Especially considering the fact that you aren't guaranteed to get the SceneManager you ask for (some plugins conflict and try to overwrite the same ST_* type), but this rarely happens in practice. Normally if you need to do advanced things with SceneManagers then you should create them yourself.

Terrain

This section is related to the Terrain Scene Manager. Instructions for the new Terrain Component you find in Tutorial 3b.

Adding Terrain to the Scene

Now that we have that cleared up, it's time to actually create Terrain. The base SceneManager defines the SetWorldGeometry method, which subclasses use for most scene creation purposes. With the TerrainSceneManager class, it expects a filename from which to load a terrain configuration. Add the following code to your CreateScene() method:

mSceneMgr.SetWorldGeometry("terrain.cfg");


Compile and run your program. It's that easy.

Note: If you get an exception about the terrain.cfg file not found, this is probably because you added the code above to the ChooseSceneManager instead of the CreateScene method. Resources are only loaded after the ChooseSceneManager method has executed. CreateScene is the tutorials framework's method for actually populating the scene, and setting up the terrain is part of that process.

The terrain.cfg File

There are many options in the terrain.cfg file, and we will only cover the most basic for changing the images used to generate the terrain. A more detailed explanation of the terrain config file can be found here.

The TerrainSceneManager uses Heightmaps to generate terrain. You can specify the heightmap you want to use by setting the "Heightmap.image" property. You can set the texture that is used for the terrain by setting the WorldTexture property. The terrain scene manager also allows you to specify a "DetailTexture" property, which is interlaced with the WorldTexture to make the terrain look more realistic. You should find each of the images currently specified by terrain.cfg and take a look at them (they should be in the Media/materials/textures folder).

Details on how to create heightmaps have been discussed ad nauseum on the forums. Search for heightmap and you are sure to find something that you are looking for.

Lighting Terrain

We just spent the entire previous tutorial going over lights and shadows, but the bad news is it's not easy to get this to work in the TerrainSceneManager. This is better supported by the new paging functionality and it becomes available this tutorial will be modified to describe how to do this.

Sky

SkyBoxes

A SkyBox is basically a giant cube that surrounds all of the objects in the scene. The best way to describe it is to just show it to you. Add the following code to your CreateScene method:

mSceneMgr.SetSkyBox(true, "Examples/SpaceSkyBox");


Compile and run the program. Neat huh? (Note the SkyBox is grainy because the actual texture is low resolution; a higher resolution SkyBox would look much better).

There are several useful parameters for SkyBoxes that we can set when calling SetSkyBox. The first option is whether or not to enable the SkyBox. If you want to later disable the SkyBox simply call 'mSceneMgr.SetSkyBox(false, "");'. The second parameter is the material script to use for the SkyBox.

The third parameter and fourth parameters to setSkyBox are fairly important to understand. The third parameter sets the distance that the SkyBox is away from the Camera, and the fourth parameter sets whether or not the SkyBox is drawn before the rest of the scene or afterwards. So, lets see what happens when you change the distance parameter for the SkyBox from the default 5000 units to something very close:

mSceneMgr.SetSkyBox(true, "Examples/SpaceSkyBox", 10);


Nothing changed! This is because the fourth parameter that controls whether to draw the SkyBox first or not is set to true by default. If the SkyBox is drawn first, then anything rendered afterwards (like our Terrain) will be drawn on top of it, thus making the SkyBox always appear in the background. (Note that you shouldn't set the distance above to be closer than the near clip distance on the Camera or it will not be shown!) It is not actually desirable to draw the SkyBox first, because the full thing is rendered. When you draw it last, only the visible portions are drawn, which will provide a modest speed improvement. So, lets try setting our SkyBox to be drawn last:

mSceneMgr.SetSkyBox(true, "Examples/SpaceSkyBox", 5000, false);


Again, this looks just like it did before, but now the parts of the SkyBox that are not visible won't be rendered. There is one thing you have to be careful about when using this technique though. If you set the SkyBox to be too close, you could be cutting part of the scene geometry off. For example, try this:

mSceneMgr.SetSkyBox(true, "Examples/SpaceSkyBox", 100, false);


As you can see now, the terrain "pokes through" the SkyBox. Definitely not what we want. If you use SkyBoxes in your application you will have to decide how you want to use them. The speedup you get from rendering the SkyBox after the terrain is very modest, and you have to be careful not to obscure your geometry (unless that is what you are going for). Generally speaking, leaving everything past the second parameter as default is a very safe choice.

SkyDomes

SkyDomes are very similar to SkyBoxes, and you use them by calling SetSkyDome A giant cube is created around the Camera and rendered onto, but the bigest difference is the texture is "projected" onto the SkyBox in a spherical manner. You are still looking at a cube, but it looks as if the texture is wrapped around the surface of a sphere. The primary drawback to this method is that the bottom of the cube will be untextured, so you always need to have some type of terrain that hides the base.

The example texture that Ogre provides for SkyDomes will let you see this clearly. Clear out the SetSkyBox call from CreateScene method and add the following code instead:

mSceneMgr.SetSkyDome(true, "Examples/CloudySky", 5, 8);


When you run this, move the Camera to the dead center of the terrain and move the Camera so that's positioned fairly close to the surface of the terrain (this looks the best). After looking at this, press the "R" button to switch to the mesh view. As you can see, we are still looking at a cube (without the base), but it looks as if the clouds are wrapped around a sphere at the top. Also note that the movement of the clouds is a property of the "Examples/CloudySky" material, not of SkyDomes in general.

The first two paramaters of SetSkyDome are the same as SetSkyBox, and you can turn the SkyDome off by calling 'mSceneMgr.SetSkyDome(false, "");'. The third parameter is the curvature used for the SkyDome. The API reference suggests using values between 2 and 65. lower for better distance effect, but higher values for less distortion and a smoother effect. Try setting the third paramater to 2 and 65 and look at the difference. The distance effect that the API reference was referring to can be clearly seen in these screenshots. This is setting the curvature to 2:

Image

This is setting the curvature to 64:

Image

The fourth parameter is the number of times the texture is tiled, which you will need to tweak depending on the size of your texture. Be sure to note that this parameter is a Real value (floating point) and not an integer. You can tile it 1.234 times, if that's what looks good for your application. The fifth and sixth parameters are distance and drawFirst, respectively, which we have already covered in the SkyBox section.

SkyPlanes

SkyPlanes are very different from SkyBoxes and SkyDomes. Instead of a cube to render the sky texture on, we use just a single plane. (Note for all of the following SkyPlane configurations you need to be somewhere towards the middle of the terrain and close to the ground.) The first thing we are going to do is create a plane, and face it downwards. The SetSkyPlane method that we will be calling does not have a distance parameter like SkyBox and SkyPlane. Instead that parameter is set in the d variable of Plane.

Replace the SkyDome code in the CreateScene method with the following code:

Plane plane;
plane.d      = 1000;
plane.normal = Vector3.NEGATIVE_UNIT_Y;


Now that we have the plane defined, we can create the SkyPlane. Note that the fourth parameter is the size of the SkyPlane (in this case 1500x1500 units) and the fifth parameter is how many times to tile the texture:

mSceneMgr.SetSkyPlane(true, plane, "Examples/SpaceSkyPlane", 1500, 75);


Compile and run the program. There are two problems with the SkyPlane this creates here. First of all, the texture that is used is too low resolution, and it doesn't tile well. That could be fixed by simply creating a good, high resolution sky texture that tiles well. However, the primary problem with this technique is that if you look towards the horizon, you can see where the SkyPlane ends. Even if you had a good texture, it would not look good at all if you can see to the horizon. This basic use of a SkyPlane is really only useful when you have high walls (or hills) all around the viewpoint. Using a SkyPlane in that situation would be considerably less graphics-intensive than creating a full SkyBox/SkyDome.

Fortunately, that is not all we can do with a SkyPlane. The sixth parameter to the skyplane is the familiar "renderFirst" parameter which we have already covered in the SkyBox and SkyDome sections. The seventh parameter allows you to specify the curvature of the SkyPlane, so that we are no longer using a plane, but a curved surface instead. We also have to now set the number of x and y segments used to create the SkyPlane (initially the SkyPlane was one big square, but if we want curvature we need to have the plane made up of smaller squares). The eighth and ninth parameters to the function are the number of x and y segments, respectively:

mSceneMgr.SetSkyPlane(true, plane, "Examples/SpaceSkyPlane", 1500, 50, true, 1.5f, 150, 150);


Compile and run the application. Now our SkyPlane looks much better, though again the tiling could use some work. You could also use this with the cloud material instead:

mSceneMgr.SetSkyPlane(true, plane, "Examples/CloudySky", 1500, 40, true, 1.5f, 150, 150);


Compile and run the application. The motion of the clouds and the way it is tiled seems to make it look slightly worse than a SkyDome, especially when you get near the edge of the Terrain and look out onto the horizon.

One other note, you can clear the SkyPlane by calling 'mSceneMgr.SetSkyPlane(false, new Plane(), "");'

Which to Use?

Which sky to use depends entirely on your application. If you have to see all around you, even in the negative y direction, then really your only real choice is to use a SkyBox. If you have terrain, or some kind of floor which blocks the view of the negative y direction, then using a SkyDome seems to give more realistic results. For areas where you cannot see to the horizon (such as a valley surrounded by mountains on all sides, or the inner courtyard of a castle), a SkyPlane will give you very good looking results for very little GPU costs. The primary reason to use a SkyPlane, as we will see in the next section, is because it plays nicely with fog effects.

These are only suggestions. For your application you should experiment and use whatever looks the best.

Fog

The most important thing to know about setting fog is that it doesn't actually create a fog entity in empty space as you might imagine it would. Instead, fog is merely a filter applied to whatever objects you are currently looking at. This has some interesting implications, the most relevant of which is that when you stare off into nothingness (i.e. when you are not looking at an object), you do not see fog. In fact, you only see whatever the viewport background color is. So, in order to have fog look correct, we have to set the background to whatever the fog color currently is.

Another small caveat to be aware of is that when you use the TerrainSceneManager you must be careful to call the SetFog method before the SetWorldGeometry method. (In other SceneManagers it generally doesn't matter). Depending on which is called first, a different vertex program will be chosen to create the fog and terrain.

There are two basic types of fog: linear and exponential. Linear fog gets thicker in a linear fashion, while exponential fog gets thicker exponentially (every distance unit the fog thickness increases by more than it did the previous distance unit). It's easier to see the difference than to explain it, so on to the examples.

Types of Fog

The first type of fog we will look at is linear, and it's the easiest fog to understand. The first thing we are going to do after we call setWorldGeometry is set the viewport's background color. We could do this by overriding the createViewport function (like we did in the last tutorial), but sometimes we need to set it without recreating the viewport every time. Clear the SkyPlane code from your CreateScene method and replace it with the following:

ColourValue fadeColour = new ColourValue(0.9f, 0.9f, 0.9f);
mWindow.GetViewport(0).BackgroundColour = fadeColour;


You could use the GetNumViewports method to get the number of viewports and iterate through them if you have more than one viewport, but since this is rarely the case (and since we know we only have one viewport), we can just get the viewport directly. Once we set the background color, we can now create the fog:

mSceneMgr.SetFog(FogMode.FOG_LINEAR, fadeColour, 0, 50, 500);


The first parameter to the SetFog method is the type of fog (in this case, linear). The second parameter to setFog is the color of the fog we are using (in this case a very very light grey or "WhiteSmoke" for C#). The third parameter is not used in linear fog. The fourth and fifth parameters specify the range where the fog gets thicker. In this case we have set the fog starting point to be 50 and the stopping point to be 500. This means that from 0 to 50 units in front of the camera, there is no fog. From 50 to 500 units away from the Camera, the fog gets thicker in a linear fashion. At 500 units away from the Camera, you can no longer see anything other than fog. Compile and run the application.

Another type of fog that we can use is exponential fog. Instead of setting starting and stopping bounds for fog, we instead set a density for the fog (the fourth and fifth parameters are unused). Replace the previous call to SetFog with this:

mSceneMgr.SetFog(FogMode.FOG_EXP, fadeColour, 0.005f);


Compile and run the application. This creates a different look to the fog that is generated.

There is also another exponential fog which is more severe than the first one (i.e. fog gets much thicker each unit you move away from the Camera compared to the first fog function). Note that there is more fog-per-density when using FOG_EXP2. Replace the previous call to SetFog with this:

mSceneMgr.SetFog(FogMode.FOG_EXP2, fadeColour, 0.003f);


Compile and run the application again.

Fog is mostly interchangeable between the three fog types that Ogre provides. You should experiment with all three and see which looks best in your application.

Fog and Sky

You can run into some interesting problems when trying to use fog with a SkyBox and SkyDome. Since SkyDomes and SkyBoxes are just cubes, using them with fog is problematic since fog works in a spherical manner. Clear out the contents of the CreateScene method. If we cleverly choose our SkyDome and fog parameters, we can see the problem directly:

ColourValue fadeColour = new ColourValue(0.9f, 0.9f, 0.9f);
mSceneMgr.SetFog(FogMode.FOG_LINEAR, fadeColour, 0, 450, 550);
mWindow.GetViewport(0).BackgroundColour = fadeColour;
mSceneMgr.SetSkyDome(true, "Examples/CloudySky", 5, 8, 500);


Compile and run the application. If you move the camera around, you will see different portions of the SkyDome poke through the fog depending on what part of the SkyDome you are looking at:

Image

This is certainly not what we want. Another option is to use a SkyPlane instead. Replace the code in CreateScene with this:

mSceneMgr.SetWorldGeometry("terrain.cfg");
            
ColourValue fadeColour = new ColourValue(0.9f, 0.9f, 0.9f);
mSceneMgr.SetFog(FogMode.FOG_LINEAR, fadeColour, 0, 10, 1200);
mWindow.GetViewport(0).BackgroundColour = fadeColour;
 
Plane plane;
plane.d = 100;
plane.normal = Vector3.NEGATIVE_UNIT_Y;
 
mSceneMgr.SetSkyPlane(true, plane, "Examples/CloudySky", 500, 20, true, 0.5f, 150, 150);


This looks correct. If we look upwards we can see sky (which is the case in real life if the fog is just right), but it's not poking through in funny ways. No matter if you use curvature or not, this solves our problem of the user being able to see the horizon where the SkyPlane does not look right.

There is a way to make fog not affect the sky entirely, but it requires modifying the material script for the sky texture. That is beyond the scope of this tutorial, but for future reference this parameter is what disables fog for a material.

Fog as Darkness

You may not want to use sky at all when you set fog, because if the fog is thick enough you cannot see the sky anyway. The trick with fog that we described above allows us to perform a nifty graphic hack that can be useful in some cases. Instead of setting the fog to a bright color, lets set it to be very dark and see what happens (note we have set the SkyPlane to be only 10 units away from the camera, which is before the fog sets in):

ColourValue fadeColour = new ColourValue(0.1f, 0.1f, 0.1f);
mWindow.GetViewport(0).BackgroundColour = fadeColour;
mSceneMgr.SetFog(FogMode.FOG_LINEAR, fadeColour, 0, 10, 150);
mSceneMgr.SetWorldGeometry("terrain.cfg");

Plane plane;
plane.d = 10;
plane.normal = Vector3.NEGATIVE_UNIT_Y;

mSceneMgr.SetSkyPlane(true, plane, "Examples/SpaceSkyPlane", 100, 45, true, 0.5f, 150, 150);


Compile and run the application. This is what we get:

Image

Not too terrible. Of course, once you are able to, you should use proper lighting instead of this hack, but it does show the flexibility of fog, and some of the interesting things you can do with the engine. Using black fog might also be an interesting way to do a "blindness" or "darkness" spell effect if you are writing a game that uses first-person view.



Proceed to Mogre Basic Tutorial 4 Frame Listeners and Unbuffered Input


Call to undefined function mb_split()Call to undefined function mb_split()Call to undefined function mb_split()Call to undefined function mb_split()