FrameBufferObject.h

Go to the documentation of this file.

#ifndef GlobeEngine_FrameBufferObject_h
#define GlobeEngine_FrameBufferObject_h

#include "OpenGL_Includes.h"
#include "RenderBufferObject.h"
#include "Common.h"
#include "Texture.h"
#include <vector>
#include <memory>

namespace ge {
    class FrameBufferObject
    {
    public:
        enum FBOTYPE { NORMAL=0,
            COLOR,
            STENCIL_ONLY,
            DEPTH_ONLY,
            DEPTH_STENCIL, 
            HDR_ONLY} FBOTYPE;
        
    public:
        FrameBufferObject();
        virtual ~FrameBufferObject();
        
        void clear();
        void setupFrameBuffer(vmml::Vector2i _size);
        void resizeFrameBuffer(vmml::Vector2i _size);
        /*
         *  standard channel amount is 3:
         *  FragColor vec4, FragDepth float, FragIDInfo vec4
         */
        void createBasicBuffersAndColorBuffers(vmml::Vector2i _size, int _channels);
        void createBasicBufferSetup(vmml::Vector2i _size);
        void createDepthBuffer(vmml::Vector2i _size);
        void createStencilBuffer(vmml::Vector2i _size, int _channels = 3);

        /* Create a (more standard) G-Buffer. Texture formats are choosen more
        * conservatively, so we don't blow full 32-bit RGBA textures on every-
        * thing. The current setup uses:
        *
        *   - RGB8_Ax for (diffuse) color; A unused?
        *   - DEPTH32 for depth
        *   - RG16F for normals (*)
        *
        * (*) We could use RG16F and just reconstruct the Z component of the
        * normal, or use RGB10_A2 (which also needs a bit manual work due to
        * not being signed-normalized).
        */
        void createGBuffer(vmml::Vector2i _size);
        void createGBufferWithIDLayer(vmml::Vector2i _size);

        void addLayerType(ge::TextureProperties2D _prop);

        void bind();
        void release();

        //void foo(const shared_ptr<T>& p)
        const std::shared_ptr<TextureHandle> getColorTexture(GLint _index) const;
        
        void getOpenGLError(std::string _input);
        
        /*
        *  picking funtions:
        */
        GLubyte* getPickingResult(int _x, int _y, int _w, int _h, GLint _layer = 2);
        GLfloat* getPickingResultf(int _x, int _y, int _w, int _h, GLint _layer = 2);
        
        /*
        *  export framebuffer:
        */
        void saveFramebufferToFile(std::string _filePath);
    
        /*
        *  release current framebuffer and bind to the given framebuffer ID.
        *  @param _id - if nothing is set, the OpenGL Standard buffer is
        *               set to 0.
        */
        int getStandardFramebufferID();
        int lookupStandardFramebufferID();
        void setStandardFramebufferID(int _id);

        int getWidth() const;
        int getHeight() const;
        
        void printMaximumSizes();

    protected:
        void setSize(int _width, int _height);
        void createFrameBufferHandle();
        void setupTextureChannels();
        void attachColorChannels();
        /* Texture channel handling */
        //void addTextureChannel(ge::Texture::eTEXTURE_TYPES _prop, std::string _name = "");
        void addTextureChannel(ge::TextureProperties2D _prop, std::string _name = "");
        void createBasicLayerSetup();
        void attachTextureToFramebuffer(GLenum  _attachement,GLenum _textarget, GLuint _texHandle, GLint _level);
        void callDrawBuffers();
        void checkFramebufferStatus();
        void setupRenderBuffer(GLenum _internalFormat, GLenum _assignedAttachement);
        void deleteMemory();
        void deletePickbuffer();
        void deleteFrameBufferHandle();
        void retrievePickResult(int _x, int _y, int _w, int _h, GLint _layer, GLenum _format, GLenum _type);

        RenderBufferObject rbo;
        GLuint fboId;
        GLuint sboId;
        
        GLenum* colorBuffers;
        
        //std::vector< ge::Texture::eTEXTURE_TYPES > layertypes;
        std::vector< ge::TextureProperties2D > layertypes;
        //std::vector< std::shared_ptr<Texture> > colorMaps;
        std::vector< std::shared_ptr<ge::TextureHandle> > colorMaps;

        //Texture depthMap;
        //ge::Texture stencilMap;
        ge::DepthMap2Drgba stencilMap;
        
        GLsizei width;
        GLsizei height;
        
        /* last pick result */
        union {
            GLvoid* notype;
            GLfloat* alpha;
            GLubyte* rgba;
        } pickdata;

        int standardFBOid;
    };
}
#endif