Intro to FBOs

Frame Buffer Objects

Frame buffer objects (FBOs) are OpenGL objects that hold texture data which can be filled by rendering off screen, or as one of my course’s TA calls it rendering in Magic Land. FBOs are really important for graphics because they can be used to apply post processing effects, which is the act of applying an effect to an image or texture. A FBO will hold user defined textures and you can have more than one texture or even no textures attached. To apply a post process you have to render a full screen quad and run a shader that does the screen process. In the end you will have a 2D texture that is essentially a screen picture of that frame of your application. Then you just render another full screen quad and attach that texture to it too display it to the screen.

Setting up an FBO is pretty easy. You just have to create a handle then set some parameters and check if the FBO has correctly been made by quarrying openGL. Below I will go over a bare bone Create FBO function that has the capability to set up a multiple render targets (MRTs). So this function is pretty bad in the sense that it has very little flexibility and may not do what you’d want it to do. The function call accepts a Boolean to tell it which FBO attachment types to make. Although there are only 2 types the function can make, depth and colour, the normal option is really just another colour frame buffer. The function accepts pointers to texture handles and the width and height of the screen. The rest of the code below will be explained through the comments in the code. For explanations on some of the openGL code used you can just Google them for their full break down.

GLuint Game::CreateFBO(bool useColour, bool useDepth, bool useNormal, GLuint *colourTextureOut,                 GLuint *depthTextureOut, GLuint *normalTextureOut, unsigned int width, unsigned int height)

{

//this is a simple check to see if we are creating any of the frame buffers and if we are not  //return 0.

            if (!useColour && !useDepth && !useNormal)

                        return 0;

            //this is our fbo handle which is much like a texture handle.

            unsigned int fboHandle;

            // generate FBO in graphics memory

            glGenFramebuffers(1, &fboHandle);

            glBindFramebuffer(GL_FRAMEBUFFER, fboHandle);

            // create a texture for colour storage

            if (useColour && colourTextureOut)

            {

                        //create and bind fbo

                        glGenTextures(1, colourTextureOut);

                        glBindTexture(GL_TEXTURE_2D, *colourTextureOut);

//Create texture notice how we made it using GL_RGBA8 which is basically for color as //well as GL_RGBA as parameters.

                    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, width, height, 0, GL_RGBA,                    GL_UNSIGNED_BYTE, 0);

                        //set up parameters

                        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

                        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

                        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);

                        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

                       

//Notice how we use the color attachment 0 colour attachments are important for //using MRT as each frame buffer must use its own colour attachment.

                        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, *colourTextureOut, 0);

            }

            // create a texture for depth storage

            if (useDepth && depthTextureOut)

            {

                        //Create fbo

                        glGenTextures(1, depthTextureOut);

                        glBindTexture(GL_TEXTURE_2D, *depthTextureOut);

                        //Create texture

                        glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT24, width, height, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, 0);

                        //set up parameters

                        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

                        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

                        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);

                        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

                        // we use the depth attachment for depth

                        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, *depthTextureOut, 0);

            }

            if (useNormal && normalTextureOut)

            {

                        //create and bind fbo

                        glGenTextures(1, normalTextureOut);

                        glBindTexture(GL_TEXTURE_2D, *normalTextureOut);

                        //Create texture

                        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);

                        //set up parameters

                        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

                        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

                        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);

                        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

                       

                        // as the color attachment 0 has been used we need to use the next one.

                        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, GL_TEXTURE_2D, *normalTextureOut, 0);

            }

           

            // so now that we created the FBO we need to check the status of it

            int status = glCheckFramebufferStatus(GL_FRAMEBUFFER);

            if (status != GL_FRAMEBUFFER_COMPLETE)

            {          //if the FBO fails we need to delete it and all the frame buffers created

                        std::cout<<"FBO Failure" << std::endl;

                        glBindFramebuffer(GL_FRAMEBUFFER, 0);

                        glBindTexture(GL_TEXTURE_2D, 0);

                        glDeleteFramebuffers(1, &fboHandle);

                        glDeleteTextures(1, colourTextureOut);

                        glDeleteTextures(1, depthTextureOut);

                        glDeleteTextures(1, normalTextureOut);

                        *colourTextureOut       = 0;

                        *depthTextureOut       = 0;

                        *normalTextureOut      = 0;

                        return 0;

            }

            //disable some stuff

            glBindTexture(GL_TEXTURE_2D, NULL);

            glBindFramebuffer(GL_FRAMEBUFFER, NULL);

            return fboHandle;

}

                 Now that you know how to make an FBO, let me show you really quickly how you would use one. It’s simple, just like most openGL code you have to tell openGL what you’re doing. First off the GLenum is an enumeration of the color attachments that the FBO has attached. From above you’ll see that we had the color attachments 0 and 1. The next thing we do is tell openGL that we are binding a Frame Buffer and then pass it the type and the FBO handle created by the function above. Next we tell openGL that we are drawing to buffers and tell it how many by passing it the GLenum we just created. The next step is to draw the scene. Once done, you can unbind the frame buffer by binding with NULL.

void Game::DeferredFirstPass(float elapsed, float time)

{

            GLenum Buffers[] = {GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1};

           

            glBindFramebuffer(GL_FRAMEBUFFER, GbufferFBO);

            glDrawBuffers(2, Buffers);

            glViewport(0, 0, windowWidth, windowHeight);

            glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);

            this->RenderScene(0.0f, 0.0f);

            glBindFramebuffer(GL_FRAMEBUFFER, NULL);

            glViewport(0, 0, windowWidth, windowHeight);

}

                The Last smidgen of information I will give is how to use the MRT s in the shader. This is extremely easy and it really is just making your out colour an array like the code below shows. Out putting to a different index will output to a different texture in the current FBO.

#version 140

uniform sampler2D TextureData;

in vec2 texcoord;

in vec3 normal;

out vec4 outColor[2];

void main ()

{          //render to two targets save packed normals in one and textured object in the other

            outColor[1] = vec4(normal * 0.5f + 0.5f ,1.0f);

            outColor[0] = texture(TextureData, texcoord.st);

}

                The code snippets have been from a tech demo I’ve made that shows off deferred lighting, just one of the many post-processing effects that use FBOs and MTRs. Below is a screen shot of my tech demo.