Thanks for your question, it’s a good one. I didn’t really think of that when I wrote this post (I was just copying and pasting code together to get a working example). In general you’re absolutely correct: It would make sense to directly downsample from the mfbo to the OpenGL backbuffer without first binding another FBO.

I got kinda confused since all examples I can find on the internet still do it by using the intermediate FBO. If you read the last section (More info…) of http://www.opengl.org/wiki/GL_EXT_framebuffer_multisample you’ll find a short explanation, the pixel ownership test is explained here: http://www.opentk.com/doc/chapter/2/opengl/fragment-ops/pixel-ownership-test.
So one example I can think of that might go wrong if the intermediate FBO is not used: Let’s say one corner of the OpenGL window is covered by another window. Now when you blit onto the backbuffer from the mbfo the covered area is not written. Now a problem will arise if you try to read the backbuffer into a texture and display it on another area of the OpenGL window that is not covered. The part of the texture that corresponds to the covered are will contain old/undefined data.
(But if you wanted to render to a texture it should be faster with the intermediate FBO anyway.)

I hope this was helpful.

(I’m surprised that people still read this, maybe I should revise the whole post, add some more detailed explanations and source for a complete running example.)

Indeed out of all examples on the internet for how to achieve this, the only one that actually worked was yours!

Thank you for publishing this post!

aware of the GL_ARB_texture_non_power_of_two when i wrote this article.
But actually not all hardware that supports framebuffer exts also supports NPOTs (non-power-of-two textures), for example my ATI Mobility Radeon X1400 actually

doesn’t support it. The weird thing is, that it’s still able to render NPOTs, but slower. I tried this example with a NPOT:

http://nehe.gamedev.net/data/lessons/lesson.asp?lesson=06 It crashes on Linux (using grappy ati fglrx drivers) and crashes also on Windows. I heard some people

telling that it should be possible on their ATI cards even though GL_ARB_texture_non_power_of_two is not supported to get NPOTS running (but with a remarkable performance penalty).
I guess that in those cases it is actually not the hardware that supports NPOTs but only a slow software implementation (that was provided in the driver to keep

things OpenGL 2.0 compliant) what would explain the loss of fps. But anyway, my laptop just crashes it says it’s OpenGL 2.0 compatible… but thanks to you I just found out that it’s not… OpenGL 2.0 is supposed to support this!

Thanks for your remark, good one!

Now my code works perfect.

i found the 2 bugs in your code and submitted a working example here: http://pastebin.ca/1192017
i ‘only’ have linux here right now, so i switched over to glew instead of glee and changed some of the header, but it should be working for you as well with little changes.
the mistakes were:
glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, 16, GL_DEPTH_COMPONENT, width, height);
instead of
glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, 16, width, height); (nasty one… )
and that you have to unbind the currently attached fbo before you can draw to the main window framebuffer. i’ll actually add this to my example code… you might not be the last one to fall into this trap!! thanks

and you might actually also want to add GLUT_DEPTH to the initDisplay call, otherwise it looks strange

I hope I could help, gl