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:
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:
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.
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.
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.
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.
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.
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.
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.
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!).
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 🙂
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:
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.
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:
Here, metalness is read from specular and roughness from specular.
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.t<a href="http://wiki.libsdl.org/SDL_GameControllerAddMappingsFromFile">xt</a> in the working directory.