Ogre 13.6 released

by Pavel Rojtberg | Jan 1, 2023 | News

Ogre 13.6.0 was just released. This is the last scheduled release for the 13.x series and contains some significant bug-fixes and feature additions, which we will discuss in more detail below. We recommend all users of Ogre 13.x to update.

Generally speaking, this release brings much better lighting/ shadowing due to several bugfixes that previously degraded results.

For a full overview of the changes, see the changelog.

Table of Contents

• RTSS Terrain
• Improved LiSPSM Quality
• Image Codec implemented in Rust
• UAV support in Ogre Script and compute shaders in D3D11
• IBL support added to the RTSS

RTSS Terrain

Already mentioned in the 13.5 announcement, this has now finally landed. Thanks to the preliminary testing by the rigs-of-rods guys, the remaining bugs have been ironed out. This feature allows to easily enable multiple lights or switch to PBR equations altogether.

Additionally, the layer normal blending equations have been improved and now multi-layer terrain has improved lighting.

Improved LiSPSM Quality

Here, I finally found the bug that significantly reduced the shadowmap resolution, when using LiSPSM (see above). This bug also affected PSSM, which internally uses LiSPSM.

Additionally, I could add shadow pancaking for directional lights. This is a feature also present in Ogre Next, that improves depth shadow z-resolution and thus reduces shadow acne.

Shadow pancaking is automatically used on RenderSystems that support depth clamping, like GL3+, D3D11 and Vulkan.

Image Codec implemented in Rust

To improve the security of the Ogre codebase, I looked into using the Rust language. The most critical part of Ogre is probably texture loading, as it has to deal with a plethora of different image formats. As astart, I have implemented a new Codec_RsImage.
Image codec are plugins since Ogre 1.11, this means that the Rust part is completely optional and you do not have to update your build environment, if you dont need it.

The new Codec internally uses image-rs to load the various formats, that are all implemented in Rust and thus provide memory safety.
Unfortunately, currently the Rust implementation is slower than the highly optimized C libs that have been around for decades. However, as Firefox is using image-rs internally too, I assume performance will catch-up over time.

UAV support in Ogre Script and compute shaders in D3D11

Complementing GL3+, D3D11 now supports compute shaders as well. The respective Sample in the SampleBrowser will show you how to do it.

Additionally, that sample now got considerably simpler too, as you can now specify in the ogre script that you want to use a texture for writing in the compute shader, as

texture_unit {
   texture …
   unordered_access_mip 0
}

This will bind mipmap level 0, at the binding point of the texture_unit order UAV access (D3D11 jargon) or image load/ store (GL jargon).

IBL support added to the RTSS

Now the RTSS can add indirect, image based lighting (IBL) to PBR materials. To enable it via material scripts, you have to specify

rtshader_system {
   lighting_stage metal_roughness
   image_based_lighting texture lightroom_14b_ibl.ktx
}

Note, that it requires the metal_roughness parametrization to work. For best results, generate the cubemaps using cmgen tool of the Filament project.

While at it, the cubemap support was generally improved. Ogre now can correctly load the HDR .ktx files generated by cmgen (GL3+, D3D11 only) and also use the slightly more sane _px, _nx, _py, _ny .. layer suffixes in additon to the _fr, _bk, _lf .. suffixes it traditionally used.

Ogre 13.5 released

by Pavel Rojtberg | Oct 29, 2022 | News

Ogre 13.5.0 was just released. This release contains some significant bug-fixes and feature additions, which we will discuss in more detail below. We recommend all users of the 13.x branch to update.

For a full overview of the changes, see the changelog.

Table of Contents

• Automatic Instancing
• Non shadow-casting lights and PSSM integration
• Object Space Bones
• Modernized Codebase
• Preview: RTSS Terrain
• Ecosystem Roundup

Automatic Instancing

Visible SubEntities can now be automatically batched up for Hardware Instancing.

While this is not as fast as using the respective InstanceManager class, it requires no code changes and still offers a nice speed-up (see above).

The idea is that you specify that your vertex shader is capable of instancing – similar to how you would do for hardware skinning:

includes_instancing true

Ogre will then do the rest and provide the world matrices through an automatically created instance buffer to the shader.

The RTSS will also set the respective flag, so enabling hardware instancing now merely takes only one line in the material script:

rtshader_system
{
   transform_stage instanced
}

Non shadow-casting lights and PSSM integration

The PSSM implementation in RTSS was improved to play along with multiple light sources. While it still only supports one shadow-casting light, other non-casting light are now correctly integrated – as shown above.

While at it, the PBR lighting got some fixes too. All computations are now correctly gamma composed and the ambient lighting is no longer applied twice. Due to this your PBR materials might appear darker (as typical for a PBR workflow).

Object Space Bones

Thanks to a hint by forum user loath, Ogre now offers the option to do the bone-to-world transformation on the GPU – aka “Object Space Bones”.

Traditionally Ogre passed bones to shaders (for HW skinning) via the world_*_array auto constant. Obviously this implied the bones to be in world space. To this end, Ogre did the transformation on the CPU. While this does not add much for a few bones, it becomes noticeable if you got multiple skeletons with 40+ bones.

You can opt-in into the new behavior via MeshManager::setBonesUseObjectSpace.
Also see Renderable::getWorldTransforms for how to return the transformations for your custom renderables when doing so.

When using the RTSS for HW Skinning, it will automatically generate improved shaders, when the option is on.

Also, you can now use the bone_*_array alias instead of world_*_array for clarity. Note that world_*_array was exclusively used for bones by Ogre anyway.

Modernized Codebase

Finally, the codebase was overhauled to take advantage of C++11 constructs. Most notably, all functions are now annotated with override. This means that you can now enable -Wsuggest-override for code using Ogre to get the useful warnings.

Additionally, we now extensively use std::make_shared and for-each loops which slightly improve performance, but considerably improve code readability. The for-each refactoring is an ongoing effort by github user Joilnen.

Preview: RTSS Terrain

The RTSS implementation of the Terrain shaders is now fully feature complete compared to the previous custom shader generator implementation.
This required some architectural changes to RTSS, but now the system is more flexible as a whole.

When it comes to the Terrain component, this means that all of the RTSS flexibility is available now:

• multiple lights are now supported and benefit from the PSSM integration mentioned above
• the shadows now use the hardware PCF filtering of the RTSS implementation
• you can use the GBuffer SRS to do Deferred Shading with the Terrain
• you can use the PBR lighting SRS if you want

This is scheduled to be merged for 13.6, as I want to get a stable 13.5 out first and this is a rather invasive change (even thought there are no API breaks).

If you want to try it out right away and give feedback before it is merged, see this branch. It contains only the terrain changes on top of the 13.5.0 release.

Ecosystem Roundup

Thanks to Simon Schmeisser there are some recent Ogre 1.12 packages in Debian (compared to the previously available v1.9).
This allowed us to easily create a CI pipelines for most of the OGRECave addon projects, which will improve the stability of that code as well.

Next, our PIP package now includes the Vulkan RenderSystem. This makes ogre-python the easiest way to get started with Vulkan and Python. As far as I am aware no other python renderer exposes Vulkan yet.

Finally, my Steam Deck arrived and the first thing to do was of course this:

The additional testing on the AMD GPU in the deck resulted in some fixes for the Vulkan RenderSystem.

Ogre 13.4 released

by Pavel Rojtberg | Jun 7, 2022 | News

Ogre 13.4.0 was just released. This release contains some significant bug-fixes and feature additions, which we will discuss in more detail below. We recommend all users of the 13.x branch to update.

Table of Contents

• Extended PBR-material support
• Bullet Integration now available as a Component
• VET_INT_10_10_10_2_NORM support added
• Other Additions

For a full overview of the changes, see the changelog.

Extended PBR-material support

with blender 2.8+ and blender2ogre 0.8.3, you can now choose to export PBR metal-roughness parameters instead of converting them to a FFP approximation as before.

While at it, several bugs in the RTSS PBR implementation were fixed. Now transparency, ambient lighting and PSSM shadows play nicely with PBR.

Bullet Integration now available as a Component

In the User Survey btogre was the most popular external Ogre component with over 53% votes.

To make life for those who use it easier, it is now integrated into the main repo as a component. This allows you to just build it as part of Ogre on one hand and on the other hand this ensures that it is integration tested by our CI.

VET_INT_10_10_10_2_NORM support added

Ogre now supports normalized INT_10_10_10_2 as the vertex format. This packs 3 signed values with 10bit precision and a fourth 2bit value into 4 bytes – the size required by a single float.

If you are using normal-maps, you will notice how this format is perfect to store a tangent with parity, while only requiring 25% of storage compared to 4 floats.

Additionally, you can use it to store normals where storage requirements drop to 33% too.
In both cases the 10bit resolution is typically sufficient.

The format is natively supported by GLES3, GL3+, Vulkan and Metal meaning that you also save bandwidth and VRAM.

With the other RenderSystems, Ogre will transparently unpack the data to float at mesh load time, so you at least can benefit from smaller mesh files.
E.g. a 76 MB mesh can be reduced to 50 MB, when using packed normals and tangents.

To update your meshes, OgreMeshUpgrader gained the option -pack, to be used like:

OgreMeshUpgrader -pack your.mesh

Other Additions

In other news Bites Input now not only handles Gamepads but generic Joysticks and Ogre can be used online through Google Colab.