Hi!
Checkerboard Rendering is an upscaling method used to reduce the computation requirements for a given resolution, which can offer slightly less visual fidelity than FSR or DLSS, but which can be a lot more efficient at upscaling, and can also have a lower latency (delay between getting the lower resolution frame and outputting the higher resolution frame). Between each frame, the position of the generated pixel in the 2x2 cells gets moved to the position which was generated for the longest time (more about this below, when talking about each preset).
This means that, using Checkerboard Upscaling you can generate half the amount of pixels (which takes 50% of the processing power for a given resolution), and generate the other half of the pixels (which takes significantly less than 50% of the processing power for a given resolution), resulting in massive savings in processing power for a given resolution.
For example, 1920x1080 (2K) would generate the same amount of pixels as 1440x810 (slightly more than 1280x720 whichis 1K) and calculate the rest, 2560x1440 (3K) would generate the same amount of pixels as 1920x1080 (2K) and calculate the rest, and 3840x2160 (4K) would generate the same amount of pixels as 2880x1620 (slightly more than 2560x1440 which is 3K) and calculate the rest. Even if calculating the extra pixels takes half of hte processing power needed to generate them in the first place, that is still a 25% improvement in FPS.
Checkerboard Extrapolation Super Sampling (CxSS) is a name I think would be on-brand for the implementation of checkerboard upscaling on Intel GPUs, including integrated GPUs, and I think you could use 3 presets for the upscaling, although only the Balanced preset would be genuinely checkerboard upscaling:
Balanced level of upscaling = Balanced quality = for every 2x2 of pixels, only 2 pixels are generated, in opposing corners, the other 2 pixels being skipped = 50% upscaling = 50% quality = steps {([1,0],[0,1]),([0,1],[1,0])}, with {step}, (cell), [line], 1 = generated, 0 = calculated for the upscaling.
Low level of upscaling = High quality = for each 2x2 of pixels, 1 pixel is generated, the other 3 pixels are skipped = 25% upscaling = 75% quality = steps: {([0,1],[1,1]),([1,0],[1,1]),([1,1],[1,0]),([1,1],[0,1])}.
High level of upscalling = Low Quality = for each 2x2 pixels, 3 pixels are generated, the other 1 pixel being skipped = 75% upscaling = 25% quality = steps: {([1,0],[0,0]),([0,1],[0,0]),([0,0],[0,1]),([0,0],[1,0])}.
A crude way to implement it is to render those pixels and copy the missing pixels from the previous frame, a more refined way is to have a pixel-movement-vector map which to show the direction in which the pixels are moving from frame to frame, to reduce artifacts, and that is even without using machine learning to improve the process even more (similarly to how DLSS and FSR were imrpoved, after their crude first versions).
Another option you could add would be letting the user choose if the post-processing is done before or after the upscaling, so they can choose to lose some efficiency/processing/FPS but get a nicer image, while still gaining more FPS than without using Checkerboard Extrapolation Super Sampling (CxSS).
The link below is to a video which explains in more details the advantages and calculation methods for Checkerboard Rendering, and the image I will send after that explains visually the Balanced preset of my suggestion.
https://www.youtube.com/watch?v=dnd7l092tx8
Link Copied
