Implementing SSAO in Mogre is easier than ever thanks to the efforts of the Ogre and Mogre community. Lets take a look at what we need to do to convert the C++ implementation into C# and get this great looking effect into our game with the least amount of effort.

What is SSAO?

Screen Space Ambient Occlusion (SSAO) is a rendering technique for efficiently approximating the well-known computer graphics ambient occlusion effect in real time. The algorithm is implemented as a pixel shader, analyzing the scene depth buffer which is stored in a texture. For every pixel on the screen, the pixel shader samples the depth values around the current pixel and tries to compute the amount of occlusion from each of the sampled points.

Pros

• Can be applied easily to any scene to make it look a lot better
• Runs in screen space and therefore does not degrade with scene complexity
• Works well with dynamic scenes with lots of objects
• Runs entirely on the GPU
• Works in the same consistent way for every pixel on the screen.
• No pre-processing required, no loading time, no system memory usage.

Cons

• Chews a lot of your frame rate due to multipass smooth/blur
• Requires pixel shader capability on the graphics card
• Degrades with the screen resolution
• Objects that are outside of the screen do not contribute to occlusion
• Computed occlusion is dependent on viewing angle and camera position

SSAO in Ogre

There is a great article about implementing simple SSAO in Ogre on the Ogre Wiki. Implementing this in Ogre only requires a few simple steps:

1. Download the source code, materials and shaders.
2. Unpack the materials and shaders into your media folder.
3. Add the new sub-directories to your resource locations.
4. Add the source code files to your your project.
5. Create an instance of the PFXSSAO class and pass in your initialised RenderWindow and Camera

Converting to Mogre

Fortunately, the first 3 steps above stay exactly the same when converting this to Mogre. What we need to do is convert the PFXSSAO class from C++ to C# code. While we’re at it lets rename it to something more fitting.

public class SsaoManager : SceneManager.Listener
{
	private SceneManager _sceneManager;
	private Camera _camera;
	private Viewport _viewport;
	private RenderWindow _renderWindow;
	private CompositorInstance _compositor;

	public SsaoManager(RenderWindow renderWindow, Camera camera)
	{
		MaterialManager.Singleton.SetDefaultTextureFiltering(TextureFilterOptions.TFO_ANISOTROPIC);

		_renderWindow = renderWindow;
		_camera = camera;
		_sceneManager = camera.SceneManager;
		_viewport = camera.Viewport;

		InitialiseShadows();
		InitialiseSSAO();
	}

	private void InitialiseSSAO()
	{
		_compositor = CompositorManager.Singleton.AddCompositor(_viewport, "ssao");
		_compositor.Enabled = true;
		_compositor.NotifyMaterialRender += new CompositorInstance.Listener.NotifyMaterialRenderHandler(NotifyMaterialRender);
	}

	private void NotifyMaterialRender(uint passId, MaterialPtr material)
	{
		if (passId != 42)
			return;

		unsafe
		{
			Vector3 farCorner = _camera.GetViewMatrix(true) * _camera.WorldSpaceCorners[4];
			Pass pass = material.GetBestTechnique().GetPass(0);
			GpuProgramParametersSharedPtr parameters = pass.GetVertexProgramParameters();

			if (!parameters._findNamedConstantDefinition("farCorner").IsNull)
				parameters.SetNamedConstant("farCorner", farCorner);

			parameters = pass.GetFragmentProgramParameters();

			Matrix4 clipSpaceToImageSpace = new Matrix4(
				0.5f,    0,    0,  0.5f,
				0,   -0.5f,    0,  0.5f,
				0,      0,    1,    0,
				0,      0,    0,    1);

			if (!parameters._findNamedConstantDefinition("ptMat").IsNull)
				parameters.SetNamedConstant("ptMat", clipSpaceToImageSpace * _camera.ProjectionMatrixWithRSDepth);

			if (!parameters._findNamedConstantDefinition("far").IsNull)
				parameters.SetNamedConstant("far", _camera.FarClipDistance);
		}
	}

	public bool Enabled
	{
		get
		{
			return _compositor.Enabled;
		}
		set
		{
			_compositor.Enabled = value;
		}
	}

	private void InitialiseShadows()
	{
		_sceneManager.ShadowTextureSelfShadow = true;
		_sceneManager.SetShadowTextureCasterMaterial("shadow_caster");
		_sceneManager.ShadowTextureCount = 4;

		_sceneManager.SetShadowTextureSize(256);
		_sceneManager.SetShadowTexturePixelFormat(PixelFormat.PF_FLOAT16_RGB);
		_sceneManager.ShadowCasterRenderBackFaces = false;

		uint numShadowRTTs = _sceneManager.ShadowTextureCount;
		for (uint i = 0; i < numShadowRTTs; ++i)
		{
			TexturePtr texture = _sceneManager.GetShadowTexture(i);
			Viewport viewport = texture.GetBuffer().GetRenderTarget().GetViewport(0);
			viewport.BackgroundColour = new ColourValue(1, 1, 1, 1);
			viewport.SetClearEveryFrame(true);
		}

		_sceneManager.ShadowTechnique = ShadowTechnique.SHADOWTYPE_TEXTURE_ADDITIVE_INTEGRATED;
		_sceneManager.AddListener(this);
	}

	public override void ShadowTextureCasterPreViewProj(Light light, Camera camera, uint iteration)
	{
		float range = light.AttenuationRange;
		_camera.NearClipDistance = 0.01f;
		_camera.FarClipDistance = 99990f;
	}
}

Now all you have to do to start using SSAO in your Mogre project is create an instance of the SsaoManager like so (assuming you already have a RenderWindow and Camera):

SsaoManager ssaoManager = new SsaoManager(RenderWindow, Camera);

Results

Left: Without SSAO; Right: With SSAO

References

Simple SSAO on Ogre Wiki
SSAO on Wikipedia
A simple and practical approach to SSAO on GameDev.net

Be Sociable, Share!

•