FrameBufferObject.h

Go to the documentation of this file.

//------------------------------------------------------------------------------
// File : FramebufferObject.h
//------------------------------------------------------------------------------
// Copyright (c) 2006 Gordon Wetzstein [gordon.wetzstein@medien.uni-weimar.de]
//---------------------------------------------------------------------------
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any
// damages arising from the use of this software.
//
// Permission is granted to anyone to use this software for any
// purpose, including commercial applications, and to alter it and
// redistribute it freely, subject to the following restrictions:
//
// 1. The origin of this software must not be misrepresented; you
//    must not claim that you wrote the original software. If you use
//    this software in a product, an acknowledgment in the product
//    documentation would be appreciated but is not required.
//
// 2. Altered source versions must be plainly marked as such, and
//    must not be misrepresented as being the original software.
//
// 3. This notice may not be removed or altered from any source
//    distribution.
//
// -----------------------------------------------------------------------------
//
// Credits:
// Original RenderTexture code: Mark J. Harris
//      parts of the code are used from the original RenderTexture  
//
// -----------------------------------------------------------------------------
/*
* The pixel format for the pbuffer is controlled by the mode string passed
* into the FramebufferObject constructor. This string can have the 
*       following attributes:
*
* To specify the pixel format, use the following syntax.
*   <channels>=<bits>
* <channels> must match one of the following.
*
*       rgba=n[t]               - currently only RGBA and RGB color attachments are supported, 
*                                                               n=8, 16 or 32; 16 and 32 are half-float / float buffers,
*                                                               t for RenderTexture support
*
* The following other attributes are supported.
*
* depth=n[t]    - must have n-bit depth buffer, omit n for default (24 bits),
*                                                               n can be 16, 24 or 32 whereas 16 did not work on my machine,
*                                                               t for RenderTexture support!            
*
* stencil[=t]   - stencil buffer attachment are currently only supported in 
*                                                               combination with depth buffer attachment [both must be either
*                                                               textures or buffers], the depth attachment is set to 24 Bit.
*                                                               This is because most OpenGL driver implementations have no
*                                                               separate stencil or depth buffer - See 
*                                                               EXT_packed_depth_stencil specifications for details!
*
*       -----------------------------------------------------------------------------
*       TODO:
*       
*       - support 32 Bit color attachments
*       - support more stencil buffer attachment combinations
*       - support more color attachment formats [rg, r, g, b etc.]
*       - test ATI support
*       - float depth buffer
*       
*/

#ifndef __FRAMEBUFFER_OBJECT__
#define __FRAMEBUFFER_OBJECT__

// -----------------------------------------------------------------------------

#ifdef WIN32
        #include <windows.h>
#endif

//#include <gl/gl.h>
//#include <gl/glext.h>

//#include <glh/glh_extensions.h>

#include <GL/glew.h>

#include <iostream>
#include <vector>

// -----------------------------------------------------------------------------

#define MAX_COLOR_COMPONENTS 16

// -----------------------------------------------------------------------------

class FramebufferObject {

public:

        // ---------------------------------------------------------------------------

        enum ColorAttachmentType {
                
                RGB_8   = 0,
                RGB_16,
                RGB_32,

                RGBA_8,
                RGBA_16,
                RGBA_32,
        };

        // ---------------------------------------------------------------------------

        FramebufferObject(const char *strMode="rgba=3x8t depth=24t");
        ~FramebufferObject();

        bool                                            initialize(     unsigned int width, unsigned int height );
        bool                                            reInitialize(   unsigned int width, unsigned int height, const char *strMode="rgb=16t depth=24t" );

        void                                            beginCapture(bool bEnablePassThroughShader=true);
        
        void                                            endCapture(bool bDisablePassThroughShader=true);

        void                                            bind(int index=0);

        void                                            bindDepth(void);

        GLuint                                          getColorAttachmentID(int index = 0);

        GLuint                                          getDepthAttachmentID(void);

        GLuint                                          getStencilAttachmentID(void);

        GLenum                                          getTextureTarget(void) { return _textureTarget; }

        unsigned int                            getWidth(void);
        unsigned int                            getHeight(void);

        bool                                            checkFramebufferStatus(void);
        void                                            printFramebufferStatus(void);

        void                                            enableTextureTarget(void) { glEnable(_textureTarget); }
        void                                            disableTextureTarget(void) { glDisable(_textureTarget); }

        void                                            setMinFilter(GLint      minFilter);

        void                                            setMagFilter(GLint      magFilter);

        void                                            setWrapS(GLint  wrapS);

        void                                            setWrapT(GLint  wrapT);

protected:

        GLenum                                                                          _textureTarget;

        GLint                                                                           _colorFormat;
        GLint                                                                           _internalColorFormat;
        GLenum                                                                          _colorType;

        ColorAttachmentType                                                     _colorAttachmentDepth;

        GLenum                                                                          _depthFormat;
        GLenum                                                                          _internalDepthFormat;
        GLenum                                                                          _depthType;

        GLint                                                                           _wrapS;
        GLint                                                                           _wrapT;
        
        GLint                                                                           _minFilter;
        GLint                                                                           _magFilter;

        int                                                                                     _width;
        int                                                                                     _height;

        bool                                                                            _bFBOSupported;

        bool                                                                            _bInitialized;

        bool                                                                            _bColorAttachment;
        bool                                                                            _bColorAttachmentRenderTexture;

        bool                                                                            _bDepthAttachment;
        bool                                                                            _bDepthAttachmentRenderTexture;

        bool                                                                            _bStencilAttachment;
        bool                                                                            _bStencilAttachmentRenderTexture;
        int                                                                                     _stencilDepth;
        GLint                                                                           _internalStencilFormat;

        bool                                                                            _bPassThroughProgramInitialized;

        GLuint                                                                          _frameBufferID;

        GLuint                                                                          _colorAttachmentID[MAX_COLOR_COMPONENTS];

        int                                                                                     _numColorAttachments;

        int                                                                                     _maxNumDrawBuffers;

        GLuint                                                                          _depthAttachmentID;

        GLuint                                                                          _stencilAttachmentID;

        GLint                                                                           _viewport[4];

  
  GLenum _passthrough_program;
  GLenum _passthrough_fragment_shader;
        GLuint                                                                          _passThroughProgram;
        
        bool                                                                            _bFloatColorBuffer;

private:

        void                                                                            parseModeString(const char *modeString);

        typedef std::pair<std::string, std::string> KeyVal;
        KeyVal                                                                          getKeyValuePair(std::string token);


};

#endif