News

Ogre 13.5 released

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

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

RTSS based Terrain with multiple lights

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.

Game Highlight – SHMUP Creator

Today we want to present another Game highlight of Ogre3D based games. This time: SHMUP Creator

We asked the team behind the game if they could share some insights into the Ogre3D usage and how the game was built in general, and Suny was kind enough to provide those:

What is SHMUP Creator

SHMUP Creator is a shoot ’em up maker. It allows people to create games without any coding or scripting. The games can use 2D sprites or 3D models. The game editor offers a lot of features allowing people to create gameplay, weapons, particle effects, and so on. We tried to make this tool easy to use and powerful enough for more experienced users.
The team is tiny: I’m the only coder (+ musician + texture artist + sprite artist), and one other artist made the Art direction UI design and modeled all the 3D assets.

Ogre

I’m using Ogre 13 and the DirectX9c renderer. I only modified a few lines of Ogre code to simplify my workflow (for example, to not crash when a font is looking for a non-existent character), and I wrote a few simple particle affectors, like simple damping or another one that keeps an effect 2D. I also wrote all the shaders, trying to be pretty but fast.

Performance

Shoot ’em ups are simple games, but performance is very important. I wrote an optimized bullet engine that creates a manual mesh object per bullet type. So I can display hundreds of bullets with one draw call per type.
Also, the engine can create 3D or 2D games, and for 2D games, I’m displaying a quad per sprite. When a game is exported, I create static meshes for backgrounds to reduce the number of draw calls, and it helped quite a lot with performance. Users are quite surprised by the speed of the 3D engine. I’m not doing very fancy things (no GI or AO, no PBR for now) but it’s working quite well.

GUI and other libraries

The SHMUP Creator is mainly a tool, and obviously, the UI is a very important part of the product. I’m using MyGUI for this, with a lot of custom animations and transitions. I really enjoyed using MyGUI and I hope it will be maintained in the future! Other libraries used are Bullet for some simple ray/mesh collisions, Fmod for sound, assimp for 3D import and export, and SDL for gamepad and windows creation. I also use a tiny bit of boost and rapidxml for serialization.

Why Ogre

I started to work on this project a long, long time ago. Actually, it’s my first C++ project ever 🙂 I tried Unity, but their rendering engine was very bad at this time, so I choose Ogre. There are downsides, but the good thing for me was that I had to learn a lot of things in a variety of subjects and do everything by myself, like writing all the shaders, optimizing the rendering pipeline, etc. All that knowledge is invaluable to me and I use it every day in my day job. Also, the community is not very important those days, but people are quite friendly and I can always find someone to help me if I need some help (Thanks again Paroj!).

Spreading Ogre

SHMUP Creator is a game-making tool. I’m amazed by the quality of games made by the SHMUP Creator users: you can already play some of them on itch.io, and I hope some of them will be sold on Steam soon. So, in the end, I hope this product will help create a lot of games using Ogre 🙂

Suny

Ogre 13.4 released

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

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.

Ogre 13 User Survey Results

During the period of Jan 10. – February 10. we received 54 replies. At the same time the ogre 13.2.4 Windows SDK alone was downloaded 2188 times. So while the results are insightful, they are probably not representative.

When it comes to RenderSystems, we finally see a significant drop for the legacy systems (D3D9, GL). This will allow us to focus on new features only supported on modern APIs. However, I doubt the numbers for Vulkan, given how recent the Vulkan addition was.

The most relevant result for further development is likely the question of target audience. Here, we see an increase of the enthusiast portion at the cost of the Enterprise one. I take it as we can sacrifice some API stability to gain modern rendering techniques when moving forward.

The following one is also interesting, as the HLMS was dropped with Ogre 13 and the inclusion in the poll is a copy/ paste error. I guess that any component with less than 18 votes is not actually used, but people were merely ticking every option.

As always statistics are lies though, so better take a look at the actual numbers yourself.

Specific replies

Following the #MeanTweets idea I also wrote some short replies to the criticism, that you can read below:

read more…

Ogre 13.3 released

Ogre 13.3.0 was just released. This release contains some significant feature additions, which we will discuss in more detail below.

Table of Contents

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

PBR Material support

The most significant addition is probably built-in PBR support via the RTSS.

To enable the PBR pipeline via material scripts, specify

rtshader_system
{
   lighting_stage metal_roughness texture Default_metalRoughness.jpg
}

The parameters are expected to be in the green and blue channels (as per glTF2.0) and lighting will be done according to the Filament equations.
Alternatively, you can use material-wide settings, by omitting the texture part like:

rtshader_system
{
   lighting_stage metal_roughness
}

Here, metalness is read from specular[0] and roughness from specular[1].

Furthermore, the Assimp Plugin will automatically use the PBR pipeline, if it encounters any PBR maps. This in turn allows correctly loading and displaying glTF2 meshes – as shown in the ogre-meshviewer screenshot above.

Improved Gamepad Support

The Gamepad Support in OgreBites (via SDL2) has been improved. Now the according events are correctly delegated to ImGui, so you can control the UI with your gamepad.

Also additional gamepad mappings can be specified by placing a gamecontroller.txt in the working directory.

Ogre 13 User Survey 2022

Those of you who have been around Ogre for some time might remember that back in 2020, we conducted a survey about our user base. The results of which can be found here.

For the Ogre 13 development cycle we would like to assess to correctly emphasize the development on the most used features.

So for the next four weeks until the 10th of February, you have the chance to participate and help us to get an impression about our user base, how Ogre is used and share some wishes for the future. Simply follow the link and make your way through the 14 questions. It should not take up much time since most of the questions are simple checkbox or radio button questions.

We want to thank you all upfront for helping us to develop Ogre further and getting some valuable insight information about the people using the engine!

PS: We would be glad if you could spread the word about the survey via all available channels to all potential Ogre users, because: The more participants, the more accurate are the results of course.

Removing bloat and reducing size in Ogre Next 2.4 by up to 20%

As we mentioned last time, Ogre-Next 2.4 will be mostly focusing on maintenance and fixing code debt.

Over a week we’ve fixed a lot of warnings.

With default settings on Clang on Linux, there’s no errors (except on OgreMeshTool).

But we haven’t taken a look at deprecated warnings yet.

On Apple/XCode and MSVC there’s very few warnings now

GCC needs Wconversion off because it’s incredibly dumb. It’s got too many false positives.
Fixing them would hurt readability too much, causing more harm than good.

Some CMake settings may cause warnings, e.g. we generate lots of warnings if OGRE_CONFIG_DOUBLE is on.

We also applied clang format to everything, and added C++11 override everywhere.

We’ve also removed dead code and added an option to turn off custom memory allocators off which is the default.

We’ve removed Boost, thus CMake won’t waste its time (and that was a lot) looking for an optional dependency we didn’t really need anymore.

Overall in Debug builds we’re seeing a 20% reduction in binary size (incl. symbols)!!
While Release builds have between 1% and 3% reductions.

The only drawback is that merging code 2.3 -> 2.4 is now harder as it’s almost guaranteed to cause a merge conflict, since nearly every line got touched.

Nonetheless it seems that merging by “merge using always theirs”, then applying clang format, then seeing the diff of what’s going to be merge is a good approach to prevent bad merges and fix accidentally introducing bugs

The numbers are in MBs

Linux Clang 9 – Debug

Lib Name

Before (2.3)

After (2.4)

Diff

libOgreHlmsPbs_d.so

8,69

7,53

-15,48 %

libOgreHlmsUnlit_d.so

1,92

1,59

-20,48 %

libOgreMain_d.so

65,00

55,01

-18,17 %

libOgreMeshLodGenerator_d.so

4,27

3,71

-15,11 %

libOgreOverlay_d.so

3,87

3,30

-17,23 %

libOgreSamplesCommon_d.a

10,80

9,10

-18,64 %

libOgreSceneFormat_d.so

2,55

2,03

-25,44 %

Plugin_ParticleFX_d.so

1,79

1,63

-9,85 %

RenderSystem_GL3Plus_d.so

6,97

5,23

-33,25 %

RenderSystem_NULL_d.so

1,70

1,35

-25,87 %

RenderSystem_Vulkan_d.so

15,82

14,63

-8,18 %





Total

123,39

105,12

-17,39 %

Linux Clang 9 – Release

Lib Name

Before (2.3)

After (2.4)

Diff

libOgreHlmsPbs.so

0,80

0,78

-3,03 %

libOgreHlmsUnlit.so

0,19

0,19

-3,58 %

libOgreMain.so

7,31

6,93

-5,61 %

libOgreMeshLodGenerator.so

0,24

0,22

-5,21 %

libOgreOverlay.so

1,00

1,00

-0,14 %

libOgreSamplesCommon.a

0,43

0,41

-3,85 %

libOgreSceneFormat.so

0,23

0,23

0,95 %

Plugin_ParticleFX.so

0,25

0,24

-5,38 %

RenderSystem_GL3Plus.so

0,85

0,76

-11,86 %

RenderSystem_NULL.so

0,16

0,16

-0,94 %

RenderSystem_Vulkan.so

7,93

7,91

-0,22 %





Total

19,40

18,83

-3,02 %

MSVC 2019 – Debug

Lib Name

Before (2.3)

After (2.4)

Diff

OgreHlmsPbs_d.dll

1,89

1,82

-3,45 %

OgreHlmsPbs_d.pdb

15,53

12,82

-21,15 %

OgreHlmsUnlit_d.dll

0,47

0,45

-4,50 %

OgreHlmsUnlit_d.pdb

9,51

6,89

-37,96 %

OgreMain_d.dll

24,28

22,81

-6,45 %

OgreMain_d.pdb

101,56

81,94

-23,94 %

OgreMeshLodGenerator_d.dll

1,02

0,98

-4,90 %

OgreMeshLodGenerator_d.pdb

10,57

8,64

-22,34 %

OgreMeshTool_d.pdb

11,95

8,66

-37,98 %

OgreOverlay_d.dll

1,77

1,75

-1,45 %

OgreOverlay_d.pdb

13,28

9,50

-39,70 %

OgreSceneFormat_d.dll

0,58

0,57

-1,78 %

OgreSceneFormat_d.pdb

11,07

8,04

-37,82 %

Plugin_ParticleFX_d.dll

0,39

0,37

-5,59 %

Plugin_ParticleFX_d.pdb

6,18

5,12

-20,59 %

RenderSystem_Direct3D11_d.dll

2,02

1,90

-6,32 %

RenderSystem_Direct3D11_d.pdb

17,13

14,11

-21,37 %

RenderSystem_GL3Plus_d.dll

2,00

1,69

-18,41 %

RenderSystem_GL3Plus_d.pdb

16,17

12,25

-32,03 %

RenderSystem_NULL_d.dll

0,39

0,36

-8,09 %

RenderSystem_NULL_d.pdb

8,96

6,26

-43,04 %

RenderSystem_Vulkan_d.dll

17,69

17,58

-0,66 %

RenderSystem_Vulkan_d.pdb

104,54

87,89

-18,94 %

OgreSamplesCommon_d.lib

12,83

11,63

-10,28 %

OgreSamplesCommon_d.pdb

7,74

6,78

-14,18 %





Total

399,51

330,81

-20,77 %

MSVC 2019 – Release

Lib Name

Before (2.3)

After (2.4)

Diff

OgreHlmsPbs.dll

0,55

0,55

0,09 %

OgreHlmsUnlit.dll

0,14

0,13

-1,45 %

OgreMain.dll

6,91

6,82

-1,32 %

OgreMeshLodGenerator.dll

0,20

0,21

2,12 %

OgreOverlay.dll

0,71

0,71

-0,28 %

OgreSceneFormat.dll

0,17

0,17

0,00 %

Plugin_ParticleFX.dll

0,14

0,14

0,35 %

RenderSystem_Direct3D11.dll

0,52

0,51

-0,38 %

RenderSystem_GL3Plus.dll

0,59

0,54

-9,37 %

RenderSystem_NULL.dll

0,12

0,12

-2,54 %

RenderSystem_Vulkan.dll

3,81

3,80

-0,18 %

OgreSamplesCommon.lib

1,48

1,41

-4,72 %





Total

15,33

15,11

-1,44 %

That’s all for now. Ogre 2.3 was released just a week ago and we wanted to share such an exciting development already happening on 2.4.

Discussion in forum thread.

Ogre-Next 2.3.0 Deadalus Released and Merry Christmas!

First of all, Merry Christmas to all those who celebrate it on behalf of the OGRE Team! (and if you don’t, have a nice day too!)

Second, after a bit more than a year in development, Ogre-Next 2.3.0 is released!

Magnificent work on Device Lost handling by Eugene Golushkov!

Most games don’t care too much about device lost because games can assume they own almost the entire computer while they’re running, and nothing else will be happening. A device lost is considered a critical failure and very uncommon, typically because of a Hardware or Software malfunction. Or a Windows Update in the middle of a gaming session, in which case the gaming experience is already interrupted anyway.

However this is not true for non-gaming apps: device lost can happen because of multiple reasons, but the two most common are:

  • The graphics driver is upgraded
  • Switching from power saving mode to performance or viceversa (mostly on laptops or other mobile devices)

Due to these two reasons, device lost becomes an almost certainty for long-running applications that could encounter a graphics driver suddenly upgrading; or for mobile/laptop-oriented applications where power mode switching can be very frequent.

Recovering from device lost can range from very easy to very difficult; depending on the complexity of an application and what the application was doing at the time the device was lost.

Eugene’s work goes to great lengths to try to gracefully recover from a Device Lost.

Switch importV1 to createByImportingV1

In 2.2.2 and earlier we had a function called Mesh::importV1 which would populate a v2 mesh by filling it with data from a v1 mesh, effectively importing it.

In 2.2.3 users should use MeshManager::createByImportingV1 instead. This function ‘remembers’ which meshes have been created through a conversion process, which allows device lost handling to repeat this import process and recreate the resources.

Aside from this little difference, there are no major functionality changes and the function arguments are the same.

Shadow’s Normal Offset Bias

We’ve had a couple complaints, but it wasn’t until user SolarPortal made a more exhaustive research where we realized we were not using state of the art shadow mapping techniques.

We were relying on hlmsManager->setShadowMappingUseBackFaces( true ) to hide most self-occlussion errors, but this caused other visual errors.

Normal Offset Bias is a technique from 2011 (yes, it’s old!) which drastically improves self occlussion and shadow acne while improving overall shadow quality; and is much more robust than using inverted-culling during the caster pass.

Therefore this technique replaced the old one and the function HlmsManager::setShadowMappingUseBackFaces() has been removed.

Users can globally control normal-offset and constant biases per cascade by tweaking ShadowTextureDefinition::normalOffsetBias and ShadowTextureDefinition::constantBiasScale respectively.

You can also control them via compositors scripts in the shadow node declaration, using the new keywords constant_bias_scale and normal_offset_bias

Users porting from 2.2.x may notice their shadows are a bit different (for the better!), but may encounter some self shadowing artifacts. Thus they may have to adjust these two biases if they need to.

Unlit vertex and pixel shaders unified

Unlit shaders were still duplicating its code 3 times (one for each RenderSystem) and all of its vertex & pixel shader code has been unified into a single .any file.

Although this shouldn’t impact you at all, users porting from 2.2.x need to make sure old Hlms shader templates from Unlit don’t linger and get mixed with the new files.

Pay special attention the files from Samples/Media/Hlms/Unlit match 1:1 the ones in your project and there aren’t stray .glsl/.hlsl/.metal files from an older version.

If you have customized the Unlit implementation, you may find your customizations to be broken. But they’re easy to fix. For reference look at Colibri’s two commits which ported its Unlit customizations from 2.2.x to 2.3.0

Added HlmsMacroblock::mDepthClamp

It is now possible to toggle Depth Clamp on/off. Check if it’s supported via RSC_DEPTH_CLAMP. All desktop GPU should support it unless you’re using extremely old OpenGL drivers.
iOS supports it since A11 chip (iPhone 8 or newer)

Users upgrading from older Ogre versions should be careful their libraries and headers don’t get out of sync. A full rebuild is recommended.

The reason being is that HlmsMacroblock (which is used almost anywhere in Ogre) added a new member variable. And if a DLL or header gets out of sync, it likely won’t crash but the artifacts will be very funny (most likely depth buffer will be disabled).

Added shadow pancaking

With the addition of depth clamp, we are now able to push the near plane of directional shadow maps in PSSM (non-stable variant). This greatly enhances depth buffer precision and reduces self-occlusion and acne bugs.

This improvement may make it possible for users to try using PFG_D16_UNORM instead of PFG_D32_FLOAT for shadow mapping, halving memory consumption.

Shadow pancaking is automatically disabled when depth clamp is not supported.

Vulkan is ready!

In Ogre-Next 2.3, Vulkan is considered stable. If you find a bug, please report it.

Most notable known issue is that it appears there are some issues when integrating with Qt we haven’t looked into yet.

PluginOptional

Old timers may remember that Ogre could crash if the latest DirectX runtimes were not installed, despite having an OpenGL backend as a fallback.

This was specially true during the Win 9x and Win XP eras which may not have DirectX 9.0c support. And stopped being an issue in the last decade since… well everyone has it now.

This problem came back with the Vulkan plugin, as laptops having very old drivers (e.g. from 2014) with GPUs that were perfectly capable of running Vulkan would crash due to missing system DLLs.

Furthermore, if the GPU cannot do Vulkan, Ogre would also crash.

We added the keyword PluginOptional to the Plugins.cfg file. With this, Ogre will try to load OpenGL, D3D11, Metal and/or Vulkan; and if these plugins fail to load, they will be ignored.

Make sure to update your Plugins.cfg to use this feature to provide a good experience to all of your users, even if they’ve got old HW or SW.

Other relevant information when porting

See What’s New in Ogre 2.3 from the manual for detailed info.

Also see Root Layouts section if you are customizing Hlms implementations and want to support Vulkan.

The future: Ogre 2.4

We already have a ticket tracking 2.4 roadmap.

Rather than rendering features, Ogre 2.4 will be focusing on robusting its source code base. There is a lot of code debt which needs to be addressed.

Most notably:

  • We will change the project from “Ogre” to “Ogre-Next”. The PR is already on its way and has been sitting in the backburner because we didn’t want to risk such a potentially breaking change so close to 2.3’s release. This change will allow installing Ogre 1.x and Ogre-Next side by side at the same time
  • Move to C++11 and up
    • Users may remembers my stance on C++11 adoption. Since then, while sadly the bloat is still there (literally compiling with C++98 is just faster because std headers bring in a lot of unnecessary baggage) HW has become faster, compilers did make some marginal improvements on build speeds, and most importantly we’re seeing more trouble maintaining C++98/03 support than just moving to C++11.
    • Additionally, we’ve long been wanting to use some of the C++11 (and up) built in features such as override keyword which help improve code quality.
  • Remove dead and deprecated code
  • Remove Boost (all Boost functionality we depended on can be found on the STL in C++11)

As for features, we will work on those needed by CIVCT:

  • Metal will start using Root Layouts, just like Vulkan. This will allow us to support a lot more textures and UAVs per shader.
  • Hlms implementations have a lot of duplicate Samplers for per-pass resources. We must merge them because on D3D11 CIVCT runs out of the limit of 16 samplers.

About the 2.3.0 release

For a full list of changes see the Github release

Source and SDK is in the download page.

Discussion in forum thread.

Thanks to Open Source Robotics Corporation for sponsoring CIVCT feature for their Ignition Project