Unreal Corsa - Unreal Corsa — No New Release Yet, But A Lot Has Happened!

First of all, thank you, as always, to everyone supporting Unreal Corsa, following its development, sharing feedback, and patiently waiting for the next update. Your support really means a lot, and I want to make sure you know that even when there isn't a new build available, development is very much alive!

As I mentioned in my previous post, moving away from LUA and starting to read the data I needed directly from Assetto Corsa's private memory was a huge step forward. It opened up a lot of new possibilities, and I'm already taking advantage of them.

But there was another problem I mentioned in that post, and, incredibly enough, it turned out to be one of the biggest weaknesses in my current implementation.

Grass. A LOT of grass.

So let's talk about that first!

To simplify things a little, this is how the old system worked.

Whenever a track was loaded, Unreal Corsa would read the track's ext_config files to determine which surfaces and materials should have grass growing on them.

Then, I would discard the original Assetto Corsa grass billboard meshes, generate an orthographic 2D map with colors and specific rules determining where grass should or shouldn't grow, and use that map to place my own grass billboards across the environment.

Of course, everything was instanced. And yes, the system could place up to 12 million grass billboards.

I know, I know...

That limit was supposed to be a temporary workaround to prevent excessive memory usage, especially on systems with less available memory. Somehow, it stayed there much longer than it should have.

Once you were actually driving, the system wasn't performing too badly, thanks to LODs and rendering distance limitations. However, loading a track could take a long time because of all the processing involved.

And that 12-million-instance limit created another problem.

On shorter tracks, the grass could look extremely dense and lush. But on longer tracks, or circuits with huge terrain areas surrounding the layout, the available instances had to be distributed across a much larger area. The result? Some places looked great, while others could feel surprisingly empty.

There were also several ideas and rules I had abandoned during the original implementation because doing them properly would have required restructuring the entire system.

I knew what needed to change.

Instead of using the CPU to map areas and generate orthographic maps, I needed a system that could do this work on the GPU and on the fly.

And instead of having a fixed limit for the entire track, the amount of grass should be managed according to the area surrounding the camera.

That way, I could focus the available resources where they actually matter, rather than distributing a fixed number of instances across an entire circuit.

So I went back to the drawing board and started rebuilding the system from the ground up.

I'll explain more about the technical details in a future post, but for now, I'll let some images speak for themselves.

Keep in mind that this is still a work in progress!

I know CSP has its own rules and configurations to make grass look neatly trimmed on some circuits, wilder on others, and even different depending on the day of the week.

None of those specific rules have been implemented yet.

For now, I've mainly focused on the underlying GPU-based generation system, the overall look, and creating the textures, meshes and materials needed for the new implementation.

There is still plenty of work to do, but this is already a major improvement over the previous approach.

Whenever I got tired of staring at grass for hours, I switched to another thing I mentioned in my previous post: AMD FSR support.

I had tried implementing FSR before, but I ran into compatibility issues when trying to keep both FSR and DLSS available in the same project.

Well, it turns out the incompatibility was caused by a mistake on my side.

After investigating the problem, I finally managed to fix it!

This means that the next version of Unreal Corsa should include FSR as an additional upscaling option.

Until now, users without a GPU compatible with DLSS would fall back to TSR, Unreal Engine's native temporal upscaling solution. While TSR can produce good results, its performance can be considerably worse than FSR in some situations.

Adding FSR should therefore be a particularly good option for users with AMD GPUs, as well as anyone who simply prefers it over the alternatives.

The goal is to give everyone more flexibility when choosing the balance between image quality and performance.

In the future, I'd also like to investigate non-temporal filtering techniques, which come with their own set of challenges, particularly when integrated into a deferred rendering pipeline. Every approach has its advantages and disadvantages, and temporal solutions are no exception.

And finally, there's one more thing I've been working on!

I mentioned some of these ideas in Discord, and I'm finally making real progress towards implementing them.

The goal is to bring Assetto Corsa's entire UI into Unreal Corsa.

Think about it: telemetry apps, Pure Planner, and other Assetto Corsa apps that normally require you to switch back to the original game.

The idea is to make this information and functionality accessible directly from Unreal Corsa, without constantly pressing Alt + Tab or minimizing one application to interact with the other.

This is still under development, so I don't want to promise a release date just yet. There are several technical challenges to solve, and I need to make sure the result works reliably.

But I'm very excited about the possibilities this could open up.

The whole point of Unreal Corsa is to provide a new rendering experience while keeping Assetto Corsa's underlying simulation. Making the original game's tools more accessible from within Unreal Corsa feels like a natural next step.

I'll share more details as the implementation progresses!

Not just yet!

I could probably put together a new build right now with some of these changes, but I want to spend a little more time polishing the new implementations and making sure the next executable isn't full of bugs.

The grass system still needs work, FSR needs proper testing, and the UI integration is progressing alongside everything else.

I'd rather take a little longer and deliver something that represents a meaningful improvement over v0.0.3, instead of rushing out a build just to have something new to download.

As always, I'm developing this project largely on my own, and there are only so many hours in a day. Sometimes a feature that sounds simple on paper turns into several days of debugging, experimentation and rewriting things that were already working.

But that's part of the process.

And honestly, I'm very happy with the progress made over the last week. These are the ki

nds of improvements that might not always be immediately visible in a screenshot, but they can make a huge difference to the future of Unreal Corsa.

Thank you so much to everyone who continues to support this project, believe in what I'm trying to build, and give me the time and patience to keep pushing it forward.

There's a lot more to come.

See you on track!