News

Ogre 1.12.9 released

Ogre 1.12.9 was just released. Typically we do not write a specific announcement for minor updates, however this one contains some major new features that warrant this one.

Multi Language GPU Programs

As noted in the last progress report, even when using OgreUnifiedShader.h one had to duplicate the GpuProgram definitions in the Ogre .material files. This has been fixed in master by allowing multi-language programs to be defined like

fragment_program myFragmentShader glsl glsles hlsl
{
    source example.frag
}

This change allowed us to drop around 900 redundant loc inside the samples.

Ogre Assimp Plugin

The separate ogre-assimp project was merged into the main repository as the Codec_Assimp Plugin, which allows loading arbitrary meshes and runtime and the OgreAssimpConverter Tool for converting meshes to the Ogre .mesh format offline (which improves loading time).

Especially the introduction of Codec_Assimp is notable, as mesh loading now goes through the same Codec dispatching as image formats.

On the application side, you can then just call sceneManager->createEntity("Bike.obj") like I did in OgreMeshViewer below:

so simply loading Codec_Assimp turned that into a general-purpose mesh-viewer.

Descriptive Hardware Buffer Usage

Did you ever wonder whether your buffer usage is rather static or rather dynamic? Well at least I did as these rather abstract names do not tell you much what it means in terms of memory allocation – but wonder no more! There are now new, actually descriptive, aliases:

Old NameNew descriptive alias
HBU_STATIC_WRITE_ONLYHBU_GPU_ONLY
HBU_DYNAMIC_WRITE_ONLYHBU_CPU_TO_GPU
HBU_STATICHBU_GPU_TO_CPU
HBU_DYNAMICHBU_CPU_ONLY

So while previously you were told to use HBU_STATIC_WRITE_ONLY, you now immediately see that the buffer will end up in GPU memory. Likewise, if you use the DYNAMIC variant, the buffer will be optimized for recurrent CPU writes.

I came up with those when planning the Vulkan RenderSystem backport and those are actually borrowed from the Vulkan Memory Allocator library. There you can also find all the subtleties regarding Vulkan, that I did not bother copying to the Ogre manual.

While these flags were named with Vulkan in mind, they map surprisingly well to the Ogre ones and, most importantly, to the actual Ogre usage. After refining the meaning, it allowed dropping several superficial copies and readbacks in the D3D11 & D3D9 RenderSystems. Yes, these even map well to D3D9.

Super-fast debug drawing

Debug drawing in Ogre has been refactored and is now abstracted by the DebugDrawer API with a DefaultDebugDrawer implementation.

One advantage of this is that debug drawing code will not be sprayed across core classes. At least with 1.13 – for now we keep things as is not to break any obscure use-cases.

The main advantage however is, that debug drawing is now properly batched – whereas there was one draw-call per WireBox previously, there is now one draw-call for all wireboxes in the scene. This is also true for coordinate crosses and camera frustums.

Other highlights

  • Ogre can now be built using the latest Emscripten SDK, thaks to a contribution by Gustavo Branco
  • The Config dialog on Windows & Linux was updated to use the new Ogre logo

Ogre ecosystem roundup #6

following the last post about what is going on around Ogre, here is another update. With the Ogre 1.12.8 release, mainly the usability of Ogre was improved with the following additions.

Nicer shadows

While revising the depth-texture implementation, I noticed that we would take advantage of that feature for performance instead of quality. With depth-textures the GPU can perform bilinear interpolation of the depth-test, so a single sample (tap) roughly corresponds to a classical 4-tap PCF in the shader. So what we did was just doing a 1 sample instead of 4.
However for hardware capable of depth-textures, performance is typically not an issue, so we should rather improve quality.

The images below show crops from the ShaderSystem sample at 200%. On the left, you see the old setting, while the new setting is in the middle. On the right, you see the 4-tap shader fallback used when depth-textures are not available i.e. on D3D9 and GLES2.

Yeah, so the other news is that D3D11 finally got depth-texture (PF_DEPTH) support as well.

But what if you need to support RenderSystems without PF_DEPTH or you are on GLES2 where PF_DEPTH support is not guaranteed. Well, Ogre will now gracefully fall back to the closeset non-depth format: e.g. PF_DEPTH16 > PF_L16 and the RTSS will then deal with the differences.

While at it, I also updated the default shadow material settings to be more robust as in shadow aliasing artefacts:

Thanks to an additional round of fixes to the emscripten GLES2 backend, you can also try out the shadow improvements in a WebGL2 capable browser.

Improved Documentation

I took another look at the documentation and added a CI test to detect docstring inconsistencies like undocumented or superficial parameters. This should help improving the documentation quality of external and my own pull-requests.While at it I also added doxygen groups to several large classes. These allow tying related methods together. See e.g. the Material class:

Speaking of Materials.. did you ever wonder how they work exactly? Well, now you can take a look at

Better Python integration

Next, it kind of bothered me that one has to write so verbose code, when using the Python bindings, so I tried to take advantage of Python protocols:

# Now, instead of specifying the type as before
vp.setBackgroundColour(Ogre.ColourValue(.3, .3, .3))

# you can do
vp.setBackgroundColour((.3, .3, .3))
# or
vp.setBackgroundColour(numpy.zeros(3))
# or even
vp.setBackgroundColour(range(3))

Also, bytes objects are now supported where raw pointers are expected in the API:

# so you can do
arr = np.zeros((256, 256, 3), dtype=np.uint8)
ogre_img.loadDynamicImage(arr, 256, 256, Ogre.PF_BYTE_RGB)

OgreUnifiedShader as a Cg replacement

In an effort to provide an modern alternative for Cg and to reduce the maintenance overhead of the Ogre internal shaders, I created the OgreUnifiedShader.h that allows writing cross-platform shaders.
It is greatly inspired by the shiny library for Ogre and the shaderc tool of bgfx. However, in contrast to the latter this header is fully self-contained. All you need to do is #include it – no need to run an additional tool. It also has the advantage that you can run your shader through the standard c preprocessor (cpp) to see what the transformed shader looks like.

Just as bgfx, I opted for GLSL as the least common denominator between the shader languages. That is with some preprocessor based abstractions on top:

  • Declare Samplers with SAMPLER2D/3D/CUBE/.. macros instead of sampler2D/3D/Cube/..
  • Use the HLSL style mul(x, y) for matrix multiplication
  • Use mtxFromRows to construct matrices
  • Declare parameters with IN/ OUT macros instead of attribute/ varying
  • Use the MAIN_PARAMETERS & MAIN_DECLARATION macros instead of void main()

Here, I tried to maintain compatibility with bgfx where possible.

For an example of usage, see this PR, where I converted the Light Shafts Demo from Cg to HLSL & GLSL. As you can see there is still some room for improvements on the Ogre Material side.

Anyway, this allowed to drop 1800 lines (#1663) of shader code from the RTSS and we now have arrived at a single, GLSL based, shader library. When I joined Ogre there were 4 RTSS implementations (GLSL, GLSLES, HLSL, Cg) – with individual, subtle, bugs.

blender2ogre for Blender 2.8x

Thanks to a contribution by “Grodou” blender2ogre gained back the ability to export textures with Blender 2.8x, which is notable as we need to read from the node-based shaders for this. Together with some additional fixes by yours truly and the initial porting done by Paul Gerke, this brings exporting with Blender 2.8x roughly at the same level as with Blender 2.7x.

However, we can now take advantage of the texture semantics one gets from the Cycles materials. Thereofore, blender2ogre is able to correctly export emissive textures and, notably, normal maps.

The difference in appearance that you see above is due to the missing gamma handling. Also, to fully match what you see in Blender, we need add support for metalness and roughness maps.

Ogre ecosystem roundup #5

following the last post about what is going on around Ogre, here is another update.

Ogre 1.12.7 point release

The 1.12.7 point release kept its focus on integration. Notably, it ships the new Metal RenderSystem, that was discussed in a previous post. Also there are the following notable changes:

  • Improved Terrain Rendering: The lighting computation was pretty messed up before, which I could fix. See the following screens for comparison. Also, now vertex compression (60% less data per vertex) is used with OpenGL, too.
before – after

  • Filament shader support: Thanks to a contribution of SNiLD, I could extend the existing PBR sample to showcase the usage of Filament PBR shaders. The images below also show the existing glTF2 based material and how far you get by only using plain ogre materials.
  • New stable CSM Sample: I found another interesting Demo on the Forums and added it as a Sample to the Sample Browser. This time it is “Cascaded Shadow Mapping” which resembles the implementation you get in the CryEngine. This is a different take on the PSSM Shadow Mapping Algorithm, which is best explained by visualizing it
  • Debug view in the PSSM RTShader: While working on the CSM Sample, I found the debug split view particularly useful. Therefore, you can now visualize how the PSSM Shadow splits are placed in your scene – check out the updated ShaderSystem Sample.

OgreMeshViewer: LOD preview

If your mesh contains LOD levels, Meshviewer will now display a new tab, highlighting the currently active level

If you would like to know how to automatically generate LOD for your meshes, see the updated Ogre Tutorial.

Ogre 2.2.2 Cerberus Released!

This is a maintenance release. Efforts to port from 2.2.1 to 2.2.2 should be minimum.

Notable additions are:

  • Stable PSSM shadows technique added. Use this feature with ‘num_stable_splits 1’ in compositor scripts when defining the shadow node. Stable PSSM shadows tend to improve quality on the first splits, but they can dramatically reduce quality on the last splits of PSSM; thus using num_stable_splits 1 or 2 but not higher than that is recommended
  • D3D11 improved its handling of device lost
  • It is now possible to draw to a cubemap using MSAA, which was an oversight in Ogre 2.2.1. See the updated DynamicCubemap tutorial

For a full list see the Github release

Discussion in forum thread.

Metal RenderSystem in Ogre 1.12

The Metal RenderSystem backport from Ogre-next, that I talked about in the last round-up, now has landed in the master branch and will be available with Ogre 1.12.7. See the screenshot below for the SampleBrowser running on Metal

The current implementation pretends to have Fixed Function capabilities. Leveraging the unified FFP API introduced with the initial 1.12 release, this allows operating with a default shader. This shader only supports using a single 2D texture without lighting. E.g. vertex color is not supported. This is why the text is white instead of black in the screenshot above.

Proper lighting and texturing support, requires a Metal Shader Language support in the RTSS, which is not there yet. However, if you are mainly using custom shaders on OSX, you can start experimenting with Metal now. Furthermore, buffer updates are currently slowish, as staging buffers had to be disabled. Therefore, the Metal RenderSystem is tagged as EXPERIMENTAL.

Further development will happen at a lower pace though, as Metal neither has the large prevalence of D3D11 nor gives the synergy effects across platforms we have with OpenGL.

So if you want full Metal support in Ogre1, consider contributing and fixing bugs. The code was simplified during backporting, which shows by the size reduction from 14k loc in v2.1 to 9k loc that are now in Ogre1.

Ogre 2.2.1 Cerberus Released!

Whoa! What’s this? Didn’t you announce Ogre 2.1 Baldur was released a few days ago? Yes! Then, what’s going on?

I noticed Ogre 2.1’s release announcement atracted more popularity than I expected (thank you!!!) thus I shall explain:

Ogre 2.1 has been in development for many years, approximately since 2015.

At some point it matured and we started working on the next version: Ogre 2.2

Our regular users who stick around knew 2.1 has been stable for a while now; but we just didn’t have the time or resources to make a release (packaging binaries, ensuring everything works, etc). And many fixes from 2.2 also kept getting backported.

And 2.2 had just reached maturity too.

Ogre 2.1 was a major refactor and users porting existing code from Ogre 1.x is definitely doable, but still requires a lot of effort.

Unlike 1.x -> 2.1 transition though, 2.1 -> 2.2 transition is a much smoother experience, because it mostly touches Texture manipulation code and end users rarely manipulate a lot of Textures via code directly.

The Texture code of 2.1 was entirely replaced by the new TextureGpu code; which supports background streaming and solves many RAM issues that plagued 2.2.

Wait! 2.2.1… where’s Ogre 2.2.0?

Ogre 2.2.1 and 2.2.0 are being released concurrently. This is because during development a few of our users and testers needed to distinguish between more stable features (texture streaming) from the less stable ones (Global Illumination) and we used OGRE_VERSION_PATCH for that.

However our GI code has stabilized now.

Because there is now virtually no reason to use Ogre 2.2.0 over 2.2.1; we just went ahead and make a source-code-only release of Ogre 2.2.0 for archival reasons and a source-code + SDK release of 2.2.1

Ogre 2.2.1 also contained several bug fixes which made no sense to backport to 2.2.0 as it would only increase our work.

Download Ogre 2.2.1

Codename Cerberus

For more information, see the manual

See SW & HW Requirements
See platforms supported
See Ogre 2.1 FAQ
See What’s new in Ogre 2.2

  • Texture streaming! Completely refactored Texture code. It consumes a lot less RAM and supports background streaming
  • Voxel Cone Tracing (VCT): Semi-Realtime GI solution. Supports diffuse and specular. Can consume a lot of VRAM depending on quality. Lighting changes can be done in realtime. Changes to static objects in scene needs to rebuild voxels (not realtime)
  • Irradiance Field with Depth (IFD): Generic variant of DDGI using Voxels (consumes more VRAM) or Rasterization (slower to build). It supports diffuse only and is lower quality than VCT, but is much faster. And if completely static, consumes very little memory.
  • Per-pixel Cubemap probes
  • VR readiness: New sample showing how to integrate OpenVR SDK, deal with running start, performance optimizations such as Instanced Stereo, Hidden Area Mesh and Radial Density Mask
  • Mobile friendly: Added Load and Store actions to control how TBDR GPUs flush their caches

What’s next?

  • Stable PSSM Shadowmaps
  • Vulkan support

All branches except the Vulkan one are being merged back into master. Whatever is in master will likely become Ogre 2.2.2 one day.

That doesn’t mean Vulkan will or will not make it to 2.2.2, it’s just that we want to always keep master branch with a relatively high degree of stability (i.e. rolling release model), which the Vulkan branch cannot yet provide.

Relevant posts:

Ogre 2.1 Baldur Released!

Thank you to everyone who has been along all these many years! This release wouldn’t have been possible without you!

Thank you to every contributor (code, documentation, forum posts, art assets), to every user, to every tester that made Ogre 2.1 as stable as it is now.

This is my first experience building a binary SDK distribution. I’m used to linking to binaries built from source. If you see issues with it, ping me in the forums.

Download Ogre 2.1

Codename Baldur

First major release

For more information, see the manual
See SW & HW Requirements
See platforms supported
See Ogre 2.1 FAQ

  • Hlms (High Level Material System) to generate shaders automatically. Replaces RTSS and manual shaders
  • PBS – Physically Based Shading
  • New Compositor. More flexible, faster and powerful
  • Refactored Ogre 1.x to increase performance by several factors; using cache friendly techniques (Data Oriented Design), SIMD instructions, AZDO (Aproaching Zero Driver Overhead), auto instancing, and multithreading
  • Windows Vista/7/8/10 support, macOS via Metal and OpenGL, iOS via Metal, Linux via OpenGL
  • Many new features: Area lights, Parallax Corrected Cubemaps, Forward Clustered lights, HDR, Exponential Shadowmaps and more

Relevant posts:

Ogre ecosystem roundup #4

following the last post about what is going on around Ogre, here is another update.

Ogre 1.12.6 point release

The 1.12.6 point release kept its focus on integration. Notably, it ships the Qt OgreBites implementation, that was discussed in the previous post. Also there are the following notable changes:

  • The OSX & iOS support was vastly improved. If you had any issues with using Ogre in these enviroments, please try again with Ogre 1.12.6. The improvements include scaling the input events along the window content scaling and corrected library resolution from inside an .app bundle. I also started backporting the Metal RenderSystem to the 1.x series. See the metal-wip branch. Help is welcome.
  • Also Ogre 1.12 is now available in Debian sid & unstable. Notably, this also covers the python bindings and imgui. So prototyping a 3D application is only a apt install python3-ogre-1.12 away. Also this is a major step forward from the previous Ogre 1.9 package and allows 3rd party apps like ROS relying on it. These packges are also availble in the latest Ubuntu 20.04 release, which is based off Debian unstable.
  • Next, the MSVC SDK was refined: it now properly packages and compiles the C# ibindings. You no longer have to compile any Ogre C# sources yourself. As for C++, the pdb files are finally included, which allows you using the SDK for debugging (note that the build type still is RelWithDebInfo and not Debug).
  • The refined “Fixed Pipeline Enabled” RenderSystem option allows you to bring the legacy GL & D3D9 RenderSystems into a programmable pipeline only mode. Setting it to false is the first step, if you consider porting to GL3+ & D3D11 as it will enable the RTSS shader generation, while keeping everything else the same. It also allows you toggling forth and back between shader based and fixed pipeline to compare rendering, instead of having to pull the plug once and for all.
  • For the full list of changes and bugfixes as always consult the github release

OGRECave ecosystem

Probably the biggest strength of Ogre 1.x is the legacy of content creation tools and addons. Here, I resurrected the following tools beneath the OGRECave umbrella:

  • The meshmagick CLI .mesh optimization and manipulation tool. It allows you to conveniently change the coordinate system or merge all sub-meshes into one buffer.
  • The shiny shader meta-compiler & management library. In the mid-term we want to extend the RTSS by similar features and generally recommend to prefer the RTSS. However, there are some existing projects relying on this library, and this allows them to upgrade to recent Ogre releases.
  • The ogre-gpgpu toolkit. This is a collection of many Computer Vision and Augmented Reality related tools built around Ogre. So far, I only brought back the Ogre-CUDA bridge.
    When it is ready, this probably will be moved into the core repository. Therefore, this project can be considered as a staging area.

Qt Ogre3D integration now available in master

While there have been snippets to provide Ogre integration with Qt for a long time, there is now an officially provided version in master and scheduled for Ogre 1.12.6.

This integration requires Qt5 and builds upon the ApplicationContext abstraction living in OgreBites which already handles SDL2 windowing and Activities on Android.
In contrast to previous attempts this means that it does not follow the “QtOgreWidget approach”. This might sound less convenient, but is necessary to properly handle multiple Ogre Windows or Ogre Views. Also it should be familiar for everybody who is using the QApplication API.

The implementation lives in a separate libOgreBitesQt.so library which is only created when Qt is detected when building – so if you do not use it, you do not have to care about Qt dependencies.

The API is designed to be a drop-in replacement for ApplicationContext. This means that you can just take the setup tutorial, but use the ApplicationContextQt instead and your app will be Qt5 based.
Also, because of the Input event abstraction we did for Ogre 1.11.0, the CameraMan and Trays code will continue working – just like the Event forwarding to ImGui.

Furthermore, I have ensured that the API also fits when the Qt Event loop is used and adapts to existing projects. For this, I have ported ogitor and spacescape to the new API.
Notably, with spacescape the Ogre view is now only redrawn on-demand when things change (e.g. settings, window resize).

The exposed API is QWindow based making it lightweight as only the QtGui module is required. Also this should allow extending it for QtQuick in the future, which is also QWindow based.

For details on integration see the docs.