News

Ogre-Next 3.0.0 Eris released

It’s been 2 years since 2.3.0 and almost a year since the last 2.3.x release. It’s about time for 3.0.0!

Ogre to OgreNext name migration

We’re trying to make OgreNext and Ogre able to be installed side-by-side. The details can be found in the manual.
But the short version is that we’re moving forward to have Ogre.dll and OgreNext.dll as different DLLs so that
Ogre and OgreNext can coexist for projects who want to support both, and for Linux distros that want to support
both without getting into name clashes.

Given that this requires changes in client projects (e.g. CMakeLists.txt and *.sln, etc) that depend on OgreNext,
the old naming can be selected using the CMake variable OGRE_USE_NEW_PROJECT_NAME which defaults to OFF for 3.0, but will default to ON for 4.0; and will be scheduled for removal in OgreNext 5.0.

Dealing with ABI mismatches: AbiCookie

A common problem in our community are crashes that were caused by simple mistakes such as mixing OgreNext.dll (Release) with OgreNext.dll (Debug). Or upgrading to a newer version of OgreNext but a lingering old DLL got loaded instead.

This can cause quite cryptic errors and crashes our users were having trouble to deal with.

AbiCookie is here to fix most of this issues, as it validates on load that the DLL being loaded matches the one it is supposed to be linked against.

The ABI cookie is used like this during Ogre::Root creation:

const Ogre::AbiCookie abiCookie = Ogre::generateAbiCookie();
mRoot = OGRE_NEW Ogre::Root( &abiCookie, pluginsPath, cfgPath,
                         mWriteAccessFolder + "Ogre.log", windowTitle );

While the AbiCookie may not catch all sort of ABI mismatches, it should catch the most common mistakes.
Plugins are also always validated by the AbiCookie.

ABI Semver

Starting 3.0.0; OgreNext will follow a modified semver versioning, where 3.0.x increments must absolutely not break the ABI, but 3.x.0 MIGHT be allowed to break the ABI in subtle changes. See this ticket comment for an explanation.

For this reason, most development will focus on 4.x.x; with 3.0.x for small fixes. Changes that would involve a 3.x.0 change will mostly be considered upon contract request.

Move to C++11 and general cleanup

The biggest focus of Ogre-Next 3.0.0 was easier maintenance and porting to newer versions; rather than new features.

We started aggressively using C++11’s override keyword, which makes much easier to catch derived classes whose functions have changed slightly in signature at compile-time.

We are also enforcing clang-format through CI to ensure code formatting stays consistent across the project and contributors.

Another important factor is that we fixed all warnings (or most, depending on your compiler version) in OgreNext.
Now compiling OgreNext results in a clean log. This results in a more robust codebase.

Furthermore, including headers no longer generates warnings in client applications, which is unacceptable.

This is not to say all changes were coding-style and C++ version related.

Particularly there have been PBR/PBS changes to better match what other engines are doing, with compatibility functions to restore the old look.

Towards the future: Ogre-Next 4.0

Actually Ogre-Next 4.0 is far more exciting! Development started a year ago as 3.0.0 stabilized and 4.0 has already interesting features:

  • Multithreaded Shader Compilation and PSO generation: This greatly speeds up shader compilation, app loading and greatly reduces stutter. Available for Vulkan and Metal.
  • ParticleFX2 plugin: An alternate plugin for ParticleFX2 with a focus on performance (parallel CPU simulation + vertex-shader-based geometry generation). The original ParticleFX plugin will not be deprecated as it serves different means. Certain FXs are easier to perform with the original PFX, while PFX2 focus on performance for large amount of particles and special rendering features.
  • Alpha Hashing and Alpha Hashing with A2C (Alpha to Coverage): A very decent trick that gets impressive results to perform transparency with depth writes enabled, which means it’s Order Independent (unlike traditional alpha blending).

About the 3.0.0 release

For porting information see:

For a full list of changes see the Github release.

Source and SDK is in the download page.

Discussion in forum thread.

Thank you to everyone involved (see Github release) in making this release possible.

Ogre 14.3 released

Ogre 14.3.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 14.x branch to update.

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

Table of Contents

3D Gaussian Splatting and VET_HALF support

Ogre 14.3 now comes with an example that shows how to render 3D gaussian splats alongside with normal mesh data.

A point cloud vs the rendering as 3D gaussian splats

To efficiently store the splats they were converted from the original .ply files to native ogre .mesh files which reduced the storage by 10x. See my blog post for the details of the procedure.

To achieve this reduction the new VET_HALFx types were introduced in Ogre, which allow storing vertex attributes using 16bit floating points.

As the most useful VET_HALF3 type is neither supported by D3D9 nor by D3D11, Ogre will transparently pad it to VET_HALF4 on loading. This approach maintains reduced file sizes on these render systems with a slight increase in loading time. It’s worth mentioning that all other rendering systems, such as Metal and Vulkan, do support VET_HALF3.

Mesh Shader Support

Initial mesh shader support has been introduced in Ogre. They are supported on GL3Plus via GL_NV_mesh_shader and on Vulkan via VK_EXT_mesh_shader. Although the loading and processing of these shaders is now supported in the OgreMain component, the rest of the pipeline still needs to be developed in upcoming releases. Specifically, the generation of the meshlet structure, which is essential for the effectiveness of mesh shaders, is not yet available. Storing this structure will likely require an update to the .mesh format, which must be handled carefully to ensure backward compatibility.

Wayland Support on Linux

Thanks to the contributions of “Joakim Haugen”, “benjaminvdh” and the work of yours truly, all OpenGL and the Vulkan RenderSystems can now be compiled on Linux without any X11 dependencies and will use the Wayland display server instead. This is particularly beneficial for running Ogre on embedded devices or through WSL.

If you use OgreBites, this feature is automatically available by setting the environment variable SDL_VIDEODRIVER=wayland to instruct SDL to use Wayland. There is also initial support for OgreBitesQt, but Wayland interoperability with Qt is still under development and not fully functional with Ogre yet.

HighPy module for Python

The new HighPy module enables Ogre to function as a lightweight Python renderer. As the name implies, this module offers a high-level API, allowing users to start using Ogre without the need to read the documentation.

If you want to render a mesh it is just:

import Ogre.HighPy as ohi
ohi.window_create("ohi_world", (800, 600))
ohi.mesh_show("ohi_world", "DamagedHelmet.glb", position=(0, 0, -3))
while ohi.window_draw("ohi_world") != 27: pass

This will load the gltf2 file using the Assimp Plugin and display it using our Filament-based PBR rendering pipeline.

want to add a GUI to that? Add

import Ogre.ImGui as ImGui
ohi.window_use_imgui("ohi_world", ImGui.ShowDemoWindow)

want to display an background image?

ohi.imshow("ohi_world", "image.png")

This will use the secure image-rs rust plugin to load most image formats.

Then there is Physics with the Bullet component and headless EGL rendering on Linux..

Another improvement to the Python bindings is that Ogre now works better with Python threading. Previously we would just hog the GIL preventing any other (python) thread to run. Now you can allow python threads while waiting for vsync by calling Ogre.Root.getSingleton().allowPyThread()

Finally, the Python modules are now part of the official Docs.

Ogre ecosystem roundup #9

After the last ecosystem updates were part of the release announcements, we pick up the tradition of making a dedicated post about what is going on around Ogre.

Table of Contents

Ogre 14.2.6 release

The Ogre 14.2 release got 6th point release which is fully binary compatible with 14.2.0 and fixes many bugs and allows building with recent Vulkan SDK and SWIG releases. It is recommended for all users on 14.2.x to upgrade.

Ogre Meshviewer

Thanks to the contributions by “Guillermo Ojea Quintana” as well as by some polishing of yours truly the ogre-meshviewer 24.06 release brings many useful new features like:

  • A tabletop camera mode with a ground grid similar to blender
  • an open file-dialog and a reloading option
  • picking of the individual meshes in a .scene
  • support of orthographic projection
  • multiple layout improvements in the UI

blender2ogre

After about 1 year of development involving multiple contributors, especially with great efforts by “Guillermo Ojea Quintana”, blender2ogre 0.9.0 was released. It brings important additions like:

  • support for blender 4.x
  • import and export is now 10x faster
  • export sky boxes into .scene
  • support for recent OgreMeshUpgrader options like -pack and -optvtxcache
  • support manually specified mesh LOD levels
  • initial support for OgreNext .json materials

Ogre 14 User Survey Results

Between January 20th and February 25th, we gathered 54 responses. Among these, only one person mentioned using the pip package, whereas the ogre-python package was downloaded 3000 times. Although the findings are informative, they may not accurately reflect the broader picture due to these disparities in response patterns.

A notable observation is the duration that users have been working with ogre. The most popular choice, representing over 27% of the total, has been using it for more than 11 years. However, the group with less than 2 years of experience accounts for 42% of the overall user base. This suggests that Ogre continues to attract new users effectively.

Regarding RenderSystems, we observe a considerable decrease in usage for legacy systems (D3D9, GL). This trend allows us to explore new techniques for enhancing performance, which are not compatible with these older APIs. However, considering the absence of RTSS support for Metal, I question whether users understood that the survey was only for Ogre and not Ogre-Next.

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 14.2 released

Ogre 14.2.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 14.x branch to update.

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

Table of Contents

ImGui based ConfigDialog

The ApplicationContext can now display a ImGui based ConfigDialog, when you call runRenderingSettingsDialog().
The advantage of using ImGui is that we can get rid of platform specific toolkits like Xaw, which is necessary on Linux to be Wayland compatible. For the other platforms, this merely unifies the UI.
Furthermore, if you are already using ImGui, you will be able to integrate the Rendering Settings into your existing UI using the DrawRenderingSettings method.

The platform specific getNativeConfigDialog() based Dialogs will be removed in a future release.

Vertex Cache Optimization in MeshUpgrader

MeshUpgrader now accepts the -optvtxcache flag to improve the vertex cache utilization of the given mesh.

This reorders the index buffer of the mesh such that triangles are rendered in order of proximity. If enabled, the MeshUpgrader will print the change of the “average cache miss ratio (ACMR)” metric. It measures the number of cache misses per triangle and thus ranges from 3.0 (all 3 vertices missed) to about 0.5 for a convenient mesh.

Note that the algorithm for this was present since Ogre 1.2, it was just not exposed anywhere unless you explicitly processed your meshes by hand.

If you want to know more about the topic, see here. The algorithm in ogre has quadratic complexity though, but should provide better results.

Cleaned up samples

To integrate the ImGui based ConfigDialog, the SampleBrowser and the Samples were refactored, and now resemble more idiomatic usage of Ogre, such as input filtering using the InputListenerChain and interaction with ApplicationContext. This refactoring also led to the removal of a significant amount of boilerplate code.

Ecosystem Roundup

blender2ogre

Thanks to the work of “Guillermo Ojea Quintana” blender2ogre now supports manually specified meshes for LOD levels – in addition to auto generating mesh LOD using Blender or Ogre. See the documentation for details.

Additionally, he did some profiling and we could resolve a rather embarrassing bottleneck resulting in a import and export speed improvement of 10x.

ogre-meshviewer

Again thanks to the contributions of “Guillermo Ojea Quintana”, ogre-meshviewer now has nice ImGui based RenderSystem config dialog, wireframe mode, better LOD level inspection and a “Open File” dialog.

Ogre 14 User Survey 2024

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

For the Ogre 14 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 25th 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 17 questions.

By dedicating 5-10 minutes of your time, you provide immensely valuable feedback in understanding the current situation and needs of the Ogre community. Your support is greatly appreciated.

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.

Ogre-Next 2.3.3 Daedalus & 2.2.7 Cerberus released

These are maintenance releases. Little effort should be spent porting to these newer versions.

OgreNext 2.3.2 release is skipped because there was a relatively minor issue discovered after its release and 2.3.3 fixed that.

For a full list of changes see the Github release for 2.3.3 and the Github release for 2.2.7

Source and SDK is in the download page.

Discussion in forum thread.

Pst! We’re deciding on name candidates for the upcoming Ogre-Next 3.0 release. Make sure to chime in!

Ogre 14.1 released

Ogre 14.1.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 14.x branch to update.

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

Table of Contents

Rectangular Area Lights

A new spot light type LT_RECTLIGHT has been introduced along with the Light::setSourceSize method, enabling the rendering of rectangular area lights. In order to process this light type in your shader, verify that the spotlight_params.w autoparam is equal to 2. Then, spotlight_params.xyz contains the light width in view space, and light_attenuation.xyz contains the light height. Alternatively, just use the RTSS.

Correct whitespace loading

Historically, Ogre had incorrect glyph placement due to the initial  authors not fully understanding the freetype glyph conventions. 

The majority of these issues were addressed in version 13.0, but one notable  exception remained: the width of the whitespace character. This was  caused by a bug that prevented the width from being correctly read from freetype, so Ogre used the width of the number ‘0’ instead. This issue has now been resolved, as can seen below

However, to achieve  this, you must load the code-point 32. Failure to do so will result in  the ‘?’ placeholder character being displayed following the behaviour of ImGui.

RTSS: support for multiple shadow casting lights

Up until now, the shadow mapping SRS had only supported a single light source with the option of using parallel splits for increased resolution, due to the fact that it initially only supported PSSM.

I have finally came around to refactoring this code such it supports multiple shadow casting lights now.
By default this implements additive shadows, which was the most costly shadowing variant when not using integrated shadows. As we are using integrated shadows here, it is basically free now.
Only when using per-vertex lighting, we fall back to modulative shadows as all lights were already evaluated in the vertex shader.

You can configure the number of lights that should be considers via:

srs->setParameter("light_count", "2")

Ogre 14 released

We just tagged the Ogre 14 release, making it the new current and recommended version. We would advise you to update wherever possible, to benefit from all the fixes and improvements that made their way into the new release.
This release represents almost 2 years of work from various contributors when compared to the previous major 13 release. Compared to the last Ogre minor release (13.6), however we are only talking about 6 months. Here, you will mainly find bug-fixes and the architectural changes that justify the version number bump.

Table of Contents

For source code and pre-compiled SDKs, see the downloads page.

read more…

Ogre 13.6 released

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

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.

RTSS based Terrain with multiple lights

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

The texture shows the grid of GPU thread-groups that are generating it

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.