OpenGL SuperSampling Anti-Aliasing?

Question

At office we're working with an old GLX/Motif software that uses OpenGL's AccumulationBuffer to implement anti-aliasing for saving images. Our problem is that Apple removed the AccumulationBuffer from all of its drivers (starting from OS X 10.7.5), and some Linux drivers like Intel HDxxxx don't support it neither.

Then I would like to update the anti-aliasing code of the software for making it compatible with most actual OSs and GPUs, but keeping the generated images as beautiful as they were before (because we need them for scientific publications).

SuperSampling seems to be the oldest and the best quality anti-aliasing method, but I can't find any example of SSAA that doesn't use AccumulationBuffer. Is there a different way to implement SuperSampling with OpenGL/GLX ???

What version of GL are you targeting? The accumulation buffer is deprecated in GL 3.0, and removed in 3.1 (without `GL_ARB_compatibility`) / 3.2+ *Core*. This is why you will not find them on OS X or Intel's drivers. In lieu of the accumulation buffer, have you considered drawing into an FBO with some integer multiple of the dimensions of your default framebuffer and then performing downsampling later using a simple `GL_LINEAR` filter? — Andon M. Coleman, Mar 06 '14 at 23:12
I'm considering any method that will do good quality scene anti-aliasing (for saving images) in a compatible way with ancient an modern OpenGL implementations. Now I'll look for any "GLX FBO GL_LINEAR downsampling" example on the internet. — Fravadona, Mar 07 '14 at 10:51

score 3 · Answer 1 · answered May 17 '14 at 05:39

You can use FBOs to implement the same kind of anti-aliasing that you most likely used with accumulation buffers. The process is almost the same, except that you use a texture/renderbuffer as your "accumulation buffer". You can either use two FBOs for the process, or change the attached render target of a single render FBO.

In pseudo-code, using two FBOs, the flow looks roughly like this:

create renderbuffer rbA
create fboA (will be used for accumulation)
bind fboA
attach rbA to fboA
clear

create texture texB
create fboB (will be used for rendering)
attach texB to fboB
(create and attach a renderbuffer for the depth buffer)

loop over jitter offsets
    bind fboB
    clear
    render scene, with jitter offset applied

    bind fboA
    bind texB for texturing
    set blend function GL_CONSTANT_ALPHA, GL_ONE
    set blend color 0.0, 0.0, 0.0, 1.0 / #passes
    enable blending
    render screen size quad with simple texture sampling shader
    disable blending
end loop

bind fboA as read_framebuffer
bind default framebuffer as draw framebuffer
blit framebuffer

Full super-sampling is also possible. As Andon in the comment above suggested, you create an FBO with a render target that is a multiple of your window size in each dimension, and in the end do a down-scaling blit to your window. The whole thing tends to be slow and use a lot of memory, even with just a factor of 2.

OpenGL SuperSampling Anti-Aliasing?

1 Answers1

Linked