Godot Super Scaling, upscale or downscale your game for increased performance or visuals

So I decided to just submit to the AssetLib tonight. Feels exciting. This is my first substantial open source contribution. Hopefully it will be approved soon, I think it may take a couple days. Thanks.

Okay, I realize I had the settings wrong in OBS Studio, which was why it was so choppy. I just recorded a new video at full framerate, uploading now.

The first release is live on Github. You can wait for the AssetLib if you want, or download now if you want to try it out early. You can click the "releases" button to download the zip. Just make sure you read the readme carefully. Cheers. https://github.com/cybereality/godot-super-scaling

Here's a look at what Godot Super Scaling does with real game assets. The first shot is 1080p (but rendered with the shader) and the second is at 540p. While there is obvious pixelation and blurriness, I think it still looks quite good for 960 x 540 resolution upscaling.

Godot Super Scaling has been accepted on the Godot Asset Library. Feels great to see my work in the editor.

Honestly, the downscaling part of it is not as important. The performance cost is very high (at 200% you basically get 25% performance of native) and it doesn't look 4 times as good. I wanted it more for the upscaling, which does increase performance and still looks okay. For example, the spinning cube scene on my RX 6800 XT can get around 1,400 fps at 1080p but 2,500 fps at 540p. So that is a big improvement. Obviously 50% is kind of low, but you could do say 80% with minimal loss to picture quality. And even if performance was the same, I think it looks way better than bilinear. It is a different unique look.

Nice. Yeah, it's definitely something to add once you are finishing and polishing your game. Thanks.

Yes, it is a floating point between 0.1 and 2.0. However, there is no need to find exact numbers, because you'll have no idea what resolution your users are playing at. It handles any arbitrary resolution.

Okay, I see what you are saying. Yes, it is possible to expose a resolution number (like 1600x900) and then let the code convert that to a floating point (based on your native resolution). The thing is, the full-screen effect always runs at the native resolution of your monitor. So if you are playing on a 1080p screen, you can set the scale to any acceptable value, the resulting image is always 1080p. The scale just affects the quality of the render and how it is sampled. So I don't think there is any practical value to choosing specific resolutions, I was trying to get away from that because it is limiting.

Well one thing that would be easy (and is already supported) is using a slider for the percentage scale, but then querying the actual resolution of the render target. This already works, and is shown in the video (the resolution number is dynamic, I didn't hard code it). So that would be easy to do, and on the game level. The add-on allows access to all that information.

No that wouldn't work because I am not changing the actual rendering code. But as @Megalomaniak says, far objects take less pixels, and the depth buffer is non-linear, so this already happens in OpenGL normally.

But what you are actually asking about is called Variable Rate Shading, which is an Nvidia DX12 feature but AMD also has the same thing called Variable Shading.

https://gpuopen.com/fidelityfx-variable-shading/

This is much more advanced and currently requires DirectX12. Though I guess we could make an open-source version for Vulkan in Godot 4.0, though it would need to be part of the core rendering code, not an add-on.

For Godot 4.0, it is FSR that they integrated (FidelityFX Super Resolution). Not Variable Shading. FidelityFX is the brand name of AMDs' open-source APIs, that include many different features, like upscaling, sharpening, this variable shading thing, ambient occlusion, a denoiser, and many other features. But they are all basically separate modules you need to integrate by themselves, not just one package. You can read more here: https://www.amd.com/en/technologies/radeon-software-fidelityfx

Also, my shader works in a similar way to FSR and shares a lot in common, though I am using a different algorithm. FSR is superior overall for sure, at least I think in terms of performance and quality at scales around 80%. But I did some tests, and it looks like my solution actually looks better at lower resolution, like 50% which is still acceptable with Godot Super Scaling but looks horrible with FSR. I would not go as far to say that my shader is better across the board, but depending on the situation it can look substantially better.

Hmm.. just tried to port my project to Godot 4.0 and it didn't go well. The pre-alpha is pretty rough.

That's good to know, @Calinou . I love FSR and it looks great in the games I've played (like Terminator and Godfall) but I watched a video of the FSR in Godot 4.0 and it didn't look that great. And when I tried myself I couldn't get it working (but to be fair, I tried to port an existing project, I will try again with a new project when I have time).

I've published this add-on on Itch.io, you can download on my profile.

https://cybereality.itch.io/

Here is a deep dive into the technology behind Godot Super Scaling.

Umm... well I do seem to say umm quite a lot. Here is the game: when you watch the video, every time I say "umm" you have to take a shot of tequila!

So I went through several revisions before I landed on this solution. The whole thing was done in about 2 weeks while I was still working on the demo.

Originally it was only super sampling anti-aliasing, which is still in there, but ended up being too blurry by itself and also tanked performance when increasing resolution scaling too high.

I experimented with Lanczos, and had something sort of working, but it didn't have the quality I wanted and would have needed a sharpening pass like FSR does, but the code just got too complex and I didn't like it.

I also considered just porting FSR, since that is open source, but I read through the code and it is extremely complicated and long. It also uses features that require Vulkan/DirectX12 and I'm working in OpenGL so it would have made porting difficult. So I abandoned that idea.

Finally I discovered a method called directional averaging, which is fairly straight-forward and not complex. The idea is that instead of sampling in a fixed manner (for example, just grabbing the 4 nearest pixels) you scan the image and look for patterns in the diagonals.

So here I am sampling in a sort of star/cross kind of pattern (9 taps) which computes the color difference of each pair of pixels, and then finds the most relevant 2 pixels to blend (based on the pixels that are most visible in color and also closest in color so they likely come from the same object).

This actually works well, but results in a somewhat pixelated image (though still much better than nearest neighbor or bilinear interpolation). So to fix this I add a super sampling pass, which runs at any resolution (it helps above or below native).

The super sampling takes 4 taps, but in a rotated box formation, so the pixels do not coincide, which gives better results than standard sampling (which may just pick the 4 closest pixels).

I have sliders so you can blend between the upscaling and the super sampling, which allows you to tweak how sharp or soft the image is, though in my experiments, just leaving it at 50% almost always gives the best result.

You have to attach the script SuperScaling.gd to the SuperScaling node in the scene tree. It should do this automatically, so I wonder why it is not working. How did you download/add the add-on to your project and what version of Godot are you using.