Overlays and Integer scaling

I’m on a 1080p monitor and after some toying around I decided to switch, for the time being, to integer scaling (and no curvature): I find that the loss of “real estate”, in terms of number of pixels and screen space, is not a big deal and having more freedom, in using and pushing scanlines and masks, without having to deal with moire and other unwanted effects is really great.

I have to say that the use of an overlay is not just an aesthetic thing but it also “trick” the eyes so that game area feels not as small as if it were all black.

My way of using this new set up involve a oversized overlay image 2400x1350 made in gimp using an overlay by @Duimon (I think!) plus a background image with a transparency cut: this allow me to fit the overlay to the game area by just increasing/decreasing only one variable:

input_overlay_scale_landscape [by default set to 1.130000 (this fits most 240p content)]

Having the oversized overlay means I don’t have to worry about empty space.

In my retroarch.cfg I have set aspect ratio forced to 4/3, no overscale and no integer scaling (I do the integer scaling within the shader options).

This is all nice and good and works very well for “normal” systems so for example with NES I don’t need to do anything it works “out of the box”, but for other system like PC engine all I had to do is save a core override with only the adjusted overlay scale -> input_overlay_scale_landscape = "1.210000".

The trouble comes with other systems like Arcades (only horizontal, for vertical I use a different system…) or Amiga where resolution are all over the place and they need an override on a per game basis: this is not the end of the world, obviously, and something I’m used to do with vertical games for a while, but it would be nice if this can be somehow automated!

So the question is:

is there a better way to do this? is there something that I overlooked? maybe a shader? are there other settings that can help? I see that there is a input_overlay_auto_scale that I’m not sure can be of any use in this case.

Maybe there could be an option that can automatically modify the input_overlay_scale_landscape variable depending on the resolution of the view port.

Sorry for wall of text!

Here some example of my set up (images are compressed don’t mind the image quality :sweat_smile: )

nes -> input_overlay_scale_landscape = “1.130000”

MSX -> input_overlay_scale_landscape = “1.210000”

Overlay’s actual size is 2400x1350 ( this is compressed and resized: the graphics are not mine so I don’t think is correct to share them uncompressed)

I find doing bezels through the overlay system to be too fiddly. Doing them through shaders with the mega bezel or koko AIO shaders will usually respond to different resolutions easier.

I also much prefer using integer overscale on 1080p displays, as having 5 pixels for scanlines makes a surprisingly big difference vs 4.

1 Like

Yeah, I didn’t mention it but mega-bezel and koko-aio’s shaders are the easiest way to do it, I love those projects and always keep an “updated” custom preset of both of them at the ready but using guest’s shaders directly (with the freedom of appending/prepending) makes things much snappier -> instant loading.

Overscale can be nice (I use it with C64 and CPC) but most of the time, personally, I cannot stand the chopping of the frame :sweat_smile:

It is true that using “normal” overlays can be fiddly, but with this system it all boils down to a single parameter : input_overlay_scale_landscape.

So I was thinking that maybe implementing a simple function that changes input_overlay_scale_landscape based on the Y resolution could almost fully automate the process. :innocent:

I also noticed, that there are not that many different values to keep track of and even just 4-5 different resolution solved could leave per game cfg at a bare minimum for just very few oddballs.

I don’t think the guest-advanced shaders need integer scaling to begin with. With that shader, I only use non-integer scaling and use bezels to hide the overscan area and to fill the left/right sides with something that isn’t just black.

Guest’s advance shader is very flexible and can produce a huge variety of looks, I did use it for (very) long time in non-integer scaling and results are (still) great; but using non-integer puts limits on what you can do regarding scanlines, mask and deconvergence, limits that almost vanish while using integer scaling (and no curvature): you get more freedom and less worry about moire and other unwanted artifacts.

this is an example: left integer scaled, middle non-integer, right non-integer + curvature have a look in full-screen.