Extends

This class extends others, you can call their methods on an instance of ofFbo too:

At it's core the ofFBO is a container for textures and an optional depth buffer. Kind of like, well, an OpenGL framebuffer, which is what you're normally rendering to. One way, conceptually correct but technically a bit loose, is that it's another renderer that you can write to. You can draw textures to it, draw 3D or 2D objects to it, render the view of cameras inside of it, all with one key difference: it's just an object stored on the graphics card that represents a rendered drawing pass. You can have multiple of them, draw all kinds of things inside of them, and then get all the textures out of them to play with in a shader or just draw them directly to the screen. They are, for most purposes, little render buffers that you can render to and store without needing to be drawing to the screen.

To start working with an ofFbo, you have to allocate it, the same way that you would with an ofTexture:

fbo.allocate(400, 400, GL_RGBA); // with alpha, 8 bits red, 8 bits green, 8 bits blue, 8 bits alpha, from 0 to 255 in 256 steps

Often the FBO will contain artefacts from the memory that the graphics card has just allocated for it, so it's good to clear it before starting to draw it:

    fbo.begin();
    ofClear(255,255,255, 0);
    fbo.end();

When you call begin() you're telling the framebuffer to store the rendered results of any drawing calls (or shaders for that matter) in the FBO:

float alpha = ofMap(ofGetMouseX(), 0, ofGetWidth(), 0, 255);
fbo.begin();
    ofSetColor(255,255,255, alpha);
    ofDrawRectangle(0,0,400,400);
fbo.end();

When it's time to draw your FBO, you can simply call draw:

void ofApp::draw()
{
    fbo.draw(0,0);
}

If you want to pass the FBO to say, an ofShader, you do:

shader.setUniformTexture("fboTexture", fbo.getTextureReference(0), 0);

You can also use the ofFbo::Settings object to create a more customized FBO that allows you to set the internal format of the depth and stencil textures, create multiple textures to render to, and use different texture targets, among other things.

ofFbo can be a little confusing because it wraps two related, but distinct things in OpenGL: Textures and RenderBuffers. The difference conceptually isn't huge, but it's important if you're looking to understand deeply what's going on inside the ofFbo. RenderBuffers are good for rendering to, not drawing, whereas Textures are ok for both but slightly slower. More info on both here and here

ofFbo()

ofFbo::ofFbo()

This is the default constructor for the ofFbo.

ofFbo(...)

ofFbo::ofFbo(const ofFbo &mom)

Copies all data from the mom fbo

ofFbo(...)

ofFbo::ofFbo(ofFbo &&mom)

~ofFbo()

ofFbo::~ofFbo()

activateAllDrawBuffers()

void ofFbo::activateAllDrawBuffers()

This method allows you to render the results of a shading pass to all the textures inside the FBO. It's handy if you have many textures inside your FBO, for instance, a normals texture, a colored depth texture, a color texture, and you want to have a shader render to all of them at once. It calls glDrawBuffers() internally, which you can learn more about here.

allocate(...)

void ofFbo::allocate(int width, int height, int internalformat, int numSamples=0)

Before you use the fbo you need to allocate it. This sets the width, height, and GL type of the fbo (i.e. whether it has alpha data or not) and the number of samples for MSAA. MSAA is sort of a big topic. MSAA is what you typically have in hardware on a modern graphics card. The graphics card renders to a surface that is larger than the final image, but in shading each "cluster" of samples (that will end up in a single pixel on the final screen) the pixel shader is run only once. We save a ton of fill rate, but we still burn memory bandwidth. This technique does not anti-alias any effects coming out of the shader, because the shader runs at 1x, so alpha cutouts are jagged. This is the most common way to run a forward-rendering game. MSAA does not work for a deferred renderer because lighting decisions are made after the MSAA is "resolved" (down-sized) to its final image size.

allocate(...)

void ofFbo::allocate(ofFboSettings settings)

You can also allocate the ofFbo using a Settings object

attachTexture(...)

void ofFbo::attachTexture(ofTexture &texture, GLenum internalFormat, GLenum attachmentPoint)

begin(...)

void ofFbo::begin(ofFboMode mode)

Any drawing that you do after begin() is drawn into the fbo rather than the screen. This is how you draw things into your ofFbo instance.

Documentation from code comments

Sets up the framebuffer and binds it for rendering.

The mode parameter indicates which defaults are set when binding the fbo.

The default OF_FBOMODE_PERSPECTIVE | OF_FBOMODE_MATRIXFLIP will set the screen perspective to the OF default for the fbo size, the correct viewport to cover the full fbo and will flip the orientation matrix in y so when drawing the fbo later or accesing it from a shader it's correctly oriented

Passing OF_FBOMODE_PERSPECTIVE will only set perspective and viewport

Passing OF_FBOMODE_MATRIXFLIP won't set the perspective but will flip the matrix.

Passing OF_FBOMODE_NODEFAULTS won't change anything and just bind the fbo and set it as current rendering surface in OF

Warning: This is a convenience method, and is considered unsafe in multi-window and/or multi-renderer scenarios. If you use more than one renderer, use each renderer's explicit void ofBaseGLRenderer::begin(const ofFbo & fbo, ofFboMode mode) method instead.

See also: void ofBaseGLRenderer::begin(const ofFbo & fbo, ofFboMode mode)

bind()

void ofFbo::bind()

This function is internally called by ofFbo::begin() after setting up the viewport to draw things into your ofFbo instance.

To map the fbo to ofRectangle, ofMesh, or other vertex based drawing, call

fbo.getTextureReference().bind();
mesh.draw();
fbo.getTextureReference().unbind();

Documentation from code comments

Bind OpenGL GL_FRAMEBUFFER target to this ofFbo

Warning: If you use this method, you need to manually keep track of the currently bound framebuffer, if you ever want to restore state. * use ofBaseGLRenderer::getCurrentFramebuffer() to query the current framebuffer binding state within the renderer. * Better, use the renderer's explicit method: ofBaseGLRenderer::bind(const ofFbo & fbo) to bind the fbo, to allow the renderer to keep track of any bound fbos.

See also: unbind()

See also: virtual void ofBaseGLRenderer::bind(const ofFbo & fbo)

checkGLSupport()

bool ofFbo::checkGLSupport()

This allows you quickly check whether your graphics card supports FBO objects.

checkStatus()

bool ofFbo::checkStatus()

This checks the status of your FBO object.

clear()

void ofFbo::clear()

clearColorBuffer(...)