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
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.
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.
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.
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
Or if you follow our Ogre repo, you may have seen some commits.
Yes, we’re working on Vulkan support.
So far we only got to a clear screen, so this is all you’re gonna get thus far:
It is working with 3 different drivers: AMDVLK, AMD RADV, and Intel Mesa, so that’s nice. Only X11 (via xcb library) works for now, but more Windowing systems are planned for later.
A very low level library
Vulkan is very low level, and setting this up hasn’t been easy. The motto is that all commands are submitted in order, but they are not guaranteed to end in order unless they’re properly guarded.
Want to present on screen? You better setup a semaphore so the present command waits for the GPU to finish rendering to the backbuffer.
Submitted twice to the GPU? You better sync these two submissions or else they may be reordered
On the plus side, a modern rendering library could take advantage of this to start rendering the next frame while e.g. compute postprocessing is happening on a separate queue on the current frame.
A lot of misinformation
There’s a lot of samples out there. But many of them are wrong or incomplete.
In many of the samples this is not a problem because they perform a full stall for demo purposes, but some of the more ‘real world’ samples do not.
They also do not teach how to deal with GPU systems where the present queue and the graphics rendering queue are different (I don’t know which systems have this setup, but I suspect it has to do with Optimus laptops and similar setups where GPU doing rendering is not the one hooked to the monitor).
This bug is hard to catch because often the race condition will never happen due to the nature of double and triple buffer, and worst case scenario this could result in tearing or similar artifacts (even if vsync is enabled).
Though there’s the possibility that failing to insert this barrier can result in severe artifacts in AMD GPUs due to DCC compression on render targets being dirty while rendering to it. Godot’s renderer had encountered this problem.
If I were to summarize Vulkan, it reminds me of Javascript async/promises development: Everything is asynchronous and has to be coded with promises.
Once you get into the async mindset, Vulkan makes sense.
Where to next?
There’s a lot that needs to be done: Resizing the swapchain is not yet coded, separate Graphics and Present queues is not handled, there’s zero buffer management, no textures, no shaders.
The next task I’ll be focusing on is shaders; because they are useful to show stuff on screen and see if they’re working. Even if there are no vertex buffers yet, we can use gl_VertexID tricks to render triangles on screen.
And once shaders are working, we can then test if vertex buffers work once they’re ready, and if textures work, etc.
The tasks done to achieve this can be summarized into five:
Added ‘VrData’ which is passed to Camera::setVrData. This simplifies passing per-eye view matrices and custom projection matrices required by the VR headset