FrameBuffer.hh

////////////////////////////////////////////////////////////////////////////////
// Copyright (c) 2011, Computer Graphics Group RWTH Aachen University         //
// All rights reserved.                                                       //
////////////////////////////////////////////////////////////////////////////////

#ifndef ACGL_OPENGL_OBJECTS_FRAMEBUFFER_HH
#define ACGL_OPENGL_OBJECTS_FRAMEBUFFER_HH

/*
 * This FrameBuffer class encapsulates an OpenGL frame buffer object (FBO).
 * A FrameBuffer is a target for rendering and thus consists of different "layers":
 *
 * one or no depthbuffer
 * one or no stencilbuffer
 * one (OpenGL ES) to many (hardware dependent limit) colorbuffers
 *
 * These buffers get attached to the FrameBuffer.
 *
 * There exists one system-provided frame buffer object for rendering to the screen
 * and optionaly multiple user defined frame buffer objects for offscreen rendering.
 *
 * This class does not encapsulate the system-provided FBO.
 */

#include <ACGL/ACGL.hh>

#include <ACGL/OpenGL/GL.hh>
#include <ACGL/OpenGL/Tools.hh>

#include <ACGL/OpenGL/Objects/RenderBuffer.hh>
#include <ACGL/OpenGL/Objects/Texture.hh>
#include <ACGL/Base/StringOperations.hh>

#include <tr1/memory>

namespace ACGL{
namespace OpenGL{

class FrameBuffer
{
    // ======================================================================================================== \/
    // ============================================================================================ GPU CONTEXT \/
    // ======================================================================================================== \/
private:
    static GLuint sFrameBufferContext;

    // =================================================================================================== \/
    // ============================================================================================ STATIC \/
    // =================================================================================================== \/
private:
    static GLuint msBuffers[8];

    // ==================================================================================================== \/
    // ============================================================================================ STRUCTS \/
    // ==================================================================================================== \/
public:
    //! An attachment can be a texture or a render buffer
    struct Attachment
    {
        std::string name;
        SharedTexture texture;
        SharedRenderBuffer renderBuffer;
    };

    // Per default an FBO is used for reading (glReadPixels etc) and drawing (glDraw*) but a
    // read-only/draw-only setup is also possible.
    enum TargetType {
        READ_FRAMEBUFFER      = GL_READ_FRAMEBUFFER,
        DRAW_FRAMEBUFFER      = GL_DRAW_FRAMEBUFFER,
        READ_DRAW_FRAMEBUFFER = GL_FRAMEBUFFER
    };

    // ===================================================================================================== \/
    // ============================================================================================ TYPEDEFS \/
    // ===================================================================================================== \/
public:
    typedef std::vector< Attachment > AttachmentVec;

    // ========================================================================================================= \/
    // ============================================================================================ CONSTRUCTORS \/
    // ========================================================================================================= \/
public:
    FrameBuffer(GLsizei _width, GLsizei _height)
    :   mContext(0),
        mWidth(_width),
        mHeight(_height),
        mDrawBuffers(0),
        mColorAttachments(),
        mDepthAttachment()
    {
        glGenFramebuffers(1, &mContext);
        if (openGLCriticalErrorOccured() ) {
            ACGL::Utils::error() << "could not generate framebuffer!" << std::endl;
            return;
        }
        mDepthAttachment.name = "";
        mDepthAttachment.texture = SharedTexture();
        mDepthAttachment.renderBuffer = SharedRenderBuffer();
    }

    virtual ~FrameBuffer(void)
    {
        // buffer 0 will get ignored by OpenGL
        glDeleteFramebuffers(1, &mContext);
    }

    // ==================================================================================================== \/
    // ============================================================================================ GETTERS \/
    // ==================================================================================================== \/
public:
    inline       GLuint         getContext          (void) const { return mContext;          }
    inline       GLsizei        getWidth            (void) const { return mWidth;            }
    inline       GLsizei        getHeight           (void) const { return mHeight;           }
    inline       GLsizei        getDrawBuffers      (void) const { return mDrawBuffers;      }
    inline const AttachmentVec& getColorAttachments (void) const { return mColorAttachments; }
    inline const Attachment&    getDepthAttachment  (void) const { return mDepthAttachment;  }

    // ===================================================================================================== \/
    // ============================================================================================ WRAPPERS \/
    // ===================================================================================================== \/
public:
    inline void bindAsRenderTarget(void) const
    {
        bind();
        setDrawBuffers();
    }

    /**
     * Per default a FrameBuffer gets used for read/write operations, but we can
     * bind two different FrameBuffers for these operations!
     */
    inline void bind( TargetType _type = READ_DRAW_FRAMEBUFFER ) const
    {
        if(sFrameBufferContext == mContext)
            return;

        glBindFramebuffer(_type, mContext);
        openGLRareError(); // glBindFramebuffer can only fail if the contect is no valid FBO which shouldn't happen using this framework
        sFrameBufferContext = mContext;
    }

    inline void setDrawBuffers(void) const
    {
        glDrawBuffers(mDrawBuffers, msBuffers);
        openGLRareError();
    }

    inline void setViewport(void) const
    {
        glViewport(0, 0, mWidth, mHeight);
    }

    inline bool attachColorRenderBuffer(const SharedRenderBuffer& _renderBuffer)
    {
        if(_renderBuffer->getWidth() != mWidth && _renderBuffer->getHeight() != mHeight)
        {
            Utils::error() << "Attached render buffer for color has a wrong size!" << std::endl;
            return false;
        }
        glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + mDrawBuffers, GL_RENDERBUFFER, _renderBuffer->getContext());
        if (openGLCommonErrorOccured()) {
            Utils::error() << "Attaching of texture to the FBO failed" << std::endl;
            return false;
        }
        mDrawBuffers++;
        Attachment attachment = {"", SharedTexture(), _renderBuffer};
        mColorAttachments.push_back(attachment);
        return true;
    }

    inline bool attachColorTexture(const SharedTexture& _texture)
    {
        if(_texture->getWidth() != mWidth && _texture->getHeight() != mHeight)
        {
            Utils::error() << "Attached texture for color has a wrong size!" << std::endl;
            return false;
        }
        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + mDrawBuffers, _texture->getTarget(), _texture->getContext(), 0);
        if (openGLCommonErrorOccured()) {
            Utils::error() << "Attaching of texture to the FBO failed" << std::endl;
            return false;
        }
        mDrawBuffers++;
        Attachment attachment = {"", _texture, SharedRenderBuffer()};
        mColorAttachments.push_back(attachment);
        return true;
    }

    inline bool setDepthRenderBuffer(const SharedRenderBuffer& _renderBuffer)
    {
        if(_renderBuffer->getWidth() != mWidth && _renderBuffer->getHeight() != mHeight)
        {
            Utils::error() << "Attached render buffer for depth has a wrong size!" << std::endl;
            return false;
        }
        glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, _renderBuffer->getContext());
        #ifdef OPENGL_ES
            if( _renderBuffer->getInternalFormat() == GL_DEPTH24_STENCIL8_OES ||
                _renderBuffer->getInternalFormat() == GL_DEPTH_STENCIL_OES)
                glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, _renderBuffer->getContext());
        #else
            if( _renderBuffer->getInternalFormat() == GL_DEPTH24_STENCIL8 ||
                _renderBuffer->getInternalFormat() == GL_DEPTH_STENCIL)
                glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, _renderBuffer->getContext());
        #endif
        mDepthAttachment.renderBuffer = _renderBuffer;
        return true;
    }

    inline bool setDepthTexture(const SharedTexture& _texture)
    {
        if(_texture->getWidth() != mWidth && _texture->getHeight() != mHeight)
        {
            Utils::error() << "Attached texture for depth has a wrong size!" << std::endl;
            return false;
        }
        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, _texture->getTarget(), _texture->getContext(), 0);
        #ifdef OPENGL_ES
            if( _texture->getInternalFormat() == GL_DEPTH24_STENCIL8_OES ||
                _texture->getInternalFormat() == GL_DEPTH_STENCIL_OES)
                glFramebufferTexture2D(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, _texture->getTarget(), _texture->getContext(), 0);
        #else
            if( _texture->getInternalFormat() == GL_DEPTH24_STENCIL8 ||
                _texture->getInternalFormat() == GL_DEPTH_STENCIL)
                glFramebufferTexture2D(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, _texture->getTarget(), _texture->getContext(), 0);
        #endif
        mDepthAttachment.texture = _texture;
        return true;
    }

    inline bool isFrameBufferComplete(void)
    {
        if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
        {
            Utils::error() << "Failed to make complete FrameBuffer object: " << (glCheckFramebufferStatus(GL_FRAMEBUFFER)) << std::endl;
            return false;
        }
        return true;
    }

    // ==================================================================================================== \/
    // ============================================================================================ METHODS \/
    // ==================================================================================================== \/
protected:
    void clean(void);

    // =================================================================================================== \/
    // ============================================================================================ FIELDS \/
    // =================================================================================================== \/
protected:
    GLuint        mContext;
    GLsizei       mWidth;
    GLsizei       mHeight;
    GLsizei       mDrawBuffers;
    AttachmentVec mColorAttachments;
    Attachment    mDepthAttachment;  // depth and stencil are combined
};

typedef std::tr1::shared_ptr<FrameBuffer> SharedFrameBuffer;

} // OpenGL
} // ACGL

#endif // ACGL_OPENGL_OBJECTS_FRAMEBUFFER_HH