OpenGL multisample: the results are the same as that when multisample not used

Question

Use OpenGL (version 330) multisample, in QT framework.

The rendering image is like a star shape. I use fragment shader to render the shape intensity on the black canvas. I do not use OpenGL primitives. When multisample is not used, and when the rendering output canvas has a smaller resolution (say 400x400 pixels), I can see aliasing effects along star shape edges. If I increase the resolution, say 1500x1500 pixels, then the aliasing effects are much less obvious. So I think mutlisampling should be able to improve the result.

Now, in order to improve speed, I do not increase the resolution of the render buffer. Instead, I decide to try to use multisampling to reduce aliasing effects.

int num_samples = 2; // 4; // I guess the maximum for most graphic cards are 8

GLuint tex;
glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, tex);
glTexImage2DMultisample( GL_TEXTURE_2D_MULTISAMPLE, num_samples, GL_R11F_G11F_B10F, width, height, true );

GLuint fbo;
glGenFramebuffers( 1, &fbo );
glBindFramebuffer( GL_FRAMEBUFFER, fbo );
glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D_MULTISAMPLE, tex, 0 );

glViewport(0,0, width, height);
glEnable(GL_MULTISAMPLE);

// ... some code
// draw a rectangle, as it is 2D image processing
// OpenGL render program release

// now convert multisample frame buffer fbo to a regular frame buffer qopenglFramebufferOjbectP 
// qopenglFramebufferOjbectP is QOpenGLFramebufferObject
glBindFramebuffer(GL_READ_FRAMEBUFFER, fbo);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, qopenglFramebufferOjbectP->handle());
glBlitFramebuffer(0, 0, width, height, 0, 0, width, height, GL_COLOR_BUFFER_BIT, GL_LINEAR);

The whole code seems not to be totally wrong, since the output is the desired shape, except the anti aliasing effect. The problem is: Either I use multisample (with different sample numbers as 2 4, or 8), or I do not use multisample, the results are the same. I specially wrote the results out to images, and compared them side by side.

But if multisampling takes effect, the results should be expected to have less aliasing effects than that when multismaple is not used.

Answer 1

I use fragment shader to render the shape intensity on the black canvas. I do not use OpenGL primitives.

The basic idea of multisampling is that you're doing the same number of fragment shader invocations as non-multisampling, but a particular fragment only writes the outputs to specific samples in each pixel based on the geometry of the primitives you render. You are rendering what I presume is a quad; any apparent geometry is a fiction created by the fragment shader. Hence you have gained no benefit from the technique.

Imposter-based techniques don't usually benefit from multisampling.

There are ways to handle this, of course. The most obvious is to turn on per-sample shading, but this also effectively turns multisampling into super-sampling. That is, it isn't cheap.

A better idea would be to explicitly output a coverage mask with gl_SampleMask. It's not easy and it depends on how you generate your geometry. The idea is to, for each sample that a fragment covers, detect if that sample is within the imposter-generated geometry. If so, set that sample's mask to 1; if not, set it to 0. Thus, you generate 1 output value, and it is broadcast to the non-zero samples.

Both this and per-sample shading require GL 4.0+ (or ARB_sample_shading).