OGRE scripts offer a way to define materials at an abstraction level similar to D3D Effects and CgFX where you can define alternative techniques, each consisting of one or multiple passes.
Here, each pass defines a render pipeline state by defining blend modes and referencing shaders. The main difference in OGRE is that you cannot write inline shaders in the script file as we support different render systems with different shading languages.

Traditionally, OGRE allows to use fixed function pipeline (FFP) functionality where you do not have to write any shaders, as long as Phong shading and a fixed set of texture operations is enough for your use case.

However, modern Render Systems like D3D11 or GL3 no longer include FFP parts to reflect that modern hardware does not either and is rather based on unified programmable SIMT pipelines.

To abstract form this difference, OGRE therefore offers the Real Time Shader System (RTSS) component, that generates shaders that seamlessly replace the absent FFP functionality. In most cases OGRE is able to produce pixel-perfect results.

However, as the RTSS generates shaders internally, you can customize the rendering in much more detail then was possible with the FFP. Here, you do not have to write your own shaders but can keep the high abstraction that OGRE scripts offer and just use the rtshader_system section to declare the features you want. Still this, gives you a large amount of control how things are rendered.

The most simple thing to do is enabling per pixel lighting (which is default in 1.12 anyway) or make the shading respect the physical energy conservation rule as described here.

However, the RTSS also enables you to create complex custom render pipelines via OGRE scripts as it offers the following features (the emphasized parts require OGRE 1.12.5)

  • Hardware skinning
  • Instancing
  • GBuffers
  • Depth texture shadows
  • Lighting models
  • Triplanar Texturing
  • Offset mapping

Below are some examples how this might look like:

The first screenshot shows the instancing sample, where the RTSS extended the vertex shader to read from the instance buffer as well as the fragment shader to apply depth based shadows. If you switch to the PF_DEPTH format for the depth texture, it will automatically use hardware PCF as it does not incur any performance penalty.

The second screenshot shows integrated offset mapping with multiple lights. As this is handled by the RTSS as well, it can be combined with hardware skinning and instancing – all you need is to add a single line in your material. No need to touch any shader code, while being compatible to all supported render systems.

See the respective Samples on how to integrate this in your own projects.

Deprecation of the HLMS backport

If you are familiar with OGRE, you probably also know that there is the High Level Material System Component in OGRE1. Actually this Component is a backport of the respective core element of OGRE-next (2.1+), where it handles shader variations and thus has a similar goal of the RTSS.

However, it got only little love in OGRE1 after the initial backport, so even as of today there is no way to use it form OGRE scripts. Also I am not aware of any users, as there was not a single bug-report regarding the HLMS.
To reflect that the RTSS is in all cases the preferred alternative, the HLMS is therefore deprecated in OGRE1 and will be removed with the next release, if nobody steps up to object.