• Projects

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

Godot Super Scaling, a comprehensive post-processing effect for 3D and 2D Godot Engine games that allows you to upscale or downscale the viewport for increased performance or higher quality visuals. Supports up to 200% native resolution or down to 10%.

The code is all done and tested, just need to create the Github repo and submit to the AssetLib, which I can probably do tomorrow. This will be free and open-source MIT license. Note also that the video is a little choppy because I was recording and that ate a lot of performance. Without the video recording it is very smooth.

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.

Congratulations, that's an important step, here's to many more!

@cybereality said: 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.

@Calinou might be inclined to take a look at it perhaps. ;)

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.

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.

Call me old fashioned but I actually prefer the upscaled blurry look. Very crisp hi res textures always push things towards uncanny valley for me. I'd use this as a matter of aesthetic choice rather than for simply technical reasons.

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.

Looks really cool. I'll have to wait till I get a little farther in my game, though. Still working on the basics. Thanks for the contribution.

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

@cybereality said: 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.

Does your scaling variable allow for floating point values such as say 88.87%? Trying to get say 1600x900 out of these resolution scale systems can be a pain in my experience because many limit you only to integral values.

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.

Yeah, I mean if the variable gets exposed for players and some were to try and squeeze a more specific resolution out of it. I know I've tried to get 900p specifically out of some games and was bummed about the limit being integrals.

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.

or just expose the percentile slider and let the players do the conversions such as multiplying width and height of native and target resolutions to get the image megapixels then figure out the delta for the percentage value.

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.

Shaders are sorcery to me, but could this effect be applied based on the depth buffer such that distant objects are lower resolution (so performance gains for minimal visual impact)?