framebuffer.hpp

Go to the documentation of this file.

#ifndef __FRAMEBUFFER__
#define __FRAMEBUFFER__

#include "shader.hpp"
#include "texture.hpp"
#include <Eigen/Dense>
#include <vector>
#include <iostream>
#include <fstream>
#include <limits>
#include <GL/glew.h>

namespace Tucano
{

class Framebuffer {

protected:

    GLuint fbo_id;

    GLuint depthbuffer_id;

    std::vector<Texture> fboTextures;

    GLenum texture_type;

    Eigen::Vector2i size;

    GLenum internal_format;

    GLenum pixel_type;

    GLenum format;

    int num_samples = 1;

    bool is_binded;

    std::shared_ptr < GLuint > fboID_sptr;

    std::shared_ptr < GLuint > depthbufferID_sptr;

public:

    Framebuffer (int w, int h, int num_buffers = 1, GLenum textype = GL_TEXTURE_2D, GLenum int_frm = GL_RGBA32F, GLenum frm = GL_RGBA, GLenum pix_type = GL_UNSIGNED_BYTE  ) :
        texture_type(textype), internal_format(int_frm), pixel_type(pix_type), format(frm)
    {
        is_binded = false;
        fboTextures.clear();
        create(w, h, num_buffers);
    }

    Framebuffer (void) : texture_type(GL_TEXTURE_2D), internal_format(GL_RGBA32F), pixel_type(GL_UNSIGNED_BYTE), format(GL_RGBA)
    {
        is_binded = false;
        size = Eigen::Vector2i(0,0);

        glGenFramebuffers(1, &fbo_id);
        fboID_sptr = std::shared_ptr < GLuint > (
                new GLuint (fbo_id),
                [] (GLuint *p) {
                    glDeleteFramebuffers(1, p);
                    delete p;
                }
                );
 
        glGenRenderbuffers(1, &depthbuffer_id);
        depthbufferID_sptr = std::shared_ptr < GLuint > (
                new GLuint (depthbuffer_id),
                [] (GLuint *p) {
                    glDeleteFramebuffers(1, p);
                    delete p;
                }
                );
    }

    void create (int w, int h, int num_attachs = 1, int nsamples = 1)
    {
        num_samples = nsamples;
        size << w, h;
        int max_attachs;
        glGetIntegerv(GL_MAX_COLOR_ATTACHMENTS, &max_attachs);
        if (num_attachs > max_attachs)
        {
            cout << "WARNING : number of buffers > Max Color Attachments: " << max_attachs << endl;
        }

        if (num_samples > 1 && texture_type == GL_TEXTURE_2D)
        {
            texture_type = GL_TEXTURE_2D_MULTISAMPLE;
        }

        createFramebuffer(size[0], size[1], num_attachs);
    }

    void create (Eigen::Vector2i size, int num_attachs = 1, int nsamples = 1)
    {
        create(size[0], size[1], num_attachs, nsamples);
    }

    int bufferElements() const {
        return size[0] * size[1] * 4;
    }

    int depthBufferElements() const {
                return size[0] * size[1];
        }

    GLuint getTexID (int tex_id)
    {
        return fboTextures[tex_id].texID();
    }

    Texture* getTexture (int tex_id)
    {
        return &fboTextures[tex_id];
    }

    GLenum textureType (void)
    {
        return texture_type;
    }

    void fillTexture (int attach_id, GLubyte *data)
    {
        cout << "bytes\n";
        fboTextures[attach_id].update(data);
    }

    void fillTexture (int attach_id, GLfloat *data)
    {
        cout << "floats\n";
        fboTextures[attach_id].update(data);
    }


    virtual void bind (void)
    {
        if (!is_binded)
        {
            glBindFramebuffer(GL_FRAMEBUFFER, *fboID_sptr);
        }
        is_binded = true;
    }

    virtual void bindRenderBuffer (GLuint attachID)
    {
        bind();
        glDrawBuffer(GL_COLOR_ATTACHMENT0+attachID);
    }

    virtual void bindRenderBuffers (GLuint attachID0, GLuint attachID1)
    {
        bind();
        GLenum buffers[2] = {GL_COLOR_ATTACHMENT0+attachID0, GL_COLOR_ATTACHMENT0+attachID1};
        glDrawBuffers(2, buffers);
    }

    virtual void bindRenderBuffers (GLuint attachID0, GLuint attachID1, GLuint attachID2)
    {
        bind();
        GLenum buffers[3] = {GL_COLOR_ATTACHMENT0+attachID0, GL_COLOR_ATTACHMENT0+attachID1,
                             GL_COLOR_ATTACHMENT0+attachID2};
        glDrawBuffers(3, buffers);
    }

    virtual void bindRenderBuffers (GLuint attachID0, GLuint attachID1, GLuint attachID2, GLuint attachID3)
    {
        bind();
        GLenum buffers[4] = {GL_COLOR_ATTACHMENT0+attachID0, GL_COLOR_ATTACHMENT0+attachID1,
                             GL_COLOR_ATTACHMENT0+attachID2, GL_COLOR_ATTACHMENT0+attachID3};
        glDrawBuffers(4, buffers);
    }

    virtual void bindRenderBuffers (GLuint attachID0, GLuint attachID1, GLuint attachID2, GLuint attachID3,
                                   GLuint attachID4)
    {
        bind();
        GLenum buffers[5] = {GL_COLOR_ATTACHMENT0+attachID0, GL_COLOR_ATTACHMENT0+attachID1,
                             GL_COLOR_ATTACHMENT0+attachID2, GL_COLOR_ATTACHMENT0+attachID3,
                             GL_COLOR_ATTACHMENT0+attachID4};
        glDrawBuffers(5, buffers);
    }

    virtual void bindRenderBuffers (GLuint attachID0, GLuint attachID1, GLuint attachID2, GLuint attachID3,
                                   GLuint attachID4, GLuint attachID5)
    {
        bind();
        GLenum buffers[6] = {GL_COLOR_ATTACHMENT0+attachID0, GL_COLOR_ATTACHMENT0+attachID1,
                             GL_COLOR_ATTACHMENT0+attachID2, GL_COLOR_ATTACHMENT0+attachID3,
                             GL_COLOR_ATTACHMENT0+attachID4, GL_COLOR_ATTACHMENT0+attachID5};
        glDrawBuffers(6, buffers);
    }

    virtual void bindRenderBuffers (GLuint attachID0, GLuint attachID1, GLuint attachID2, GLuint attachID3,
                                   GLuint attachID4, GLuint attachID5, GLuint attachID6)
    {
        bind();
        GLenum buffers[7] = {GL_COLOR_ATTACHMENT0+attachID0, GL_COLOR_ATTACHMENT0+attachID1,
                             GL_COLOR_ATTACHMENT0+attachID2, GL_COLOR_ATTACHMENT0+attachID3,
                             GL_COLOR_ATTACHMENT0+attachID4, GL_COLOR_ATTACHMENT0+attachID5,
                             GL_COLOR_ATTACHMENT0+attachID6};
        glDrawBuffers(7, buffers);
    }

    virtual void bindRenderBuffers (GLuint attachID0, GLuint attachID1, GLuint attachID2, GLuint attachID3,
                                   GLuint attachID4, GLuint attachID5, GLuint attachID6, GLuint attachID7)
    {
        bind();
        GLenum buffers[8] = {GL_COLOR_ATTACHMENT0+attachID0, GL_COLOR_ATTACHMENT0+attachID1,
                             GL_COLOR_ATTACHMENT0+attachID2, GL_COLOR_ATTACHMENT0+attachID3,
                             GL_COLOR_ATTACHMENT0+attachID4, GL_COLOR_ATTACHMENT0+attachID5,
                             GL_COLOR_ATTACHMENT0+attachID6, GL_COLOR_ATTACHMENT0+attachID7};
        glDrawBuffers(8, buffers);
    }

    virtual void bindRenderBuffers (GLsizei n, GLuint* buffers)
    {
        bind();
        glDrawBuffers(n, buffers);
    }

    virtual void unbindFBO (void)
    {
        glBindFramebuffer(GL_FRAMEBUFFER, 0);
        is_binded = false;
    }

    void unbind (void)
    {
        unbindFBO();
        unbindAttachments();
        glDrawBuffer(GL_BACK);
    }

    void blitTo (Framebuffer& copyfbo, int source_attach = 0, int dest_attach = 0)
    {
        glBindFramebuffer(GL_DRAW_FRAMEBUFFER, copyfbo.getID());
        copyfbo.bindRenderBuffer(dest_attach);

        glBindFramebuffer(GL_READ_FRAMEBUFFER, fbo_id);
        glReadBuffer (GL_COLOR_ATTACHMENT0 + source_attach); 

        glBlitFramebuffer(0, 0, size[0], size[1], 0, 0, copyfbo.getWidth(), copyfbo.getHeight(), GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT, GL_NEAREST);
        copyfbo.unbind();
        unbind();
    }



    Eigen::Vector2i getSize() const {
        return size;
    }

    void clearAttachments (Eigen::Vector4f clear_color = Eigen::Vector4f::Zero())
    {
        bool was_binded = is_binded;

        bind();
        if (pixel_type == GL_RGBA32UI)
        {
            glClearColor(0, 0, 0, 0);
        }
        else
        {
            glClearColor(clear_color[0], clear_color[1], clear_color[2], clear_color[3]);
        }
        for (unsigned int i = 0; i < fboTextures.size(); ++i)
        {
            glDrawBuffer(GL_COLOR_ATTACHMENT0 + i);
            glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        }
        if (!was_binded)
        {
            unbindFBO();
        }
    }

    void clearAttachment (int attachment, Eigen::Vector4f clear_color = Eigen::Vector4f::Zero())
    {
        bool was_binded = is_binded;
        bind();
        glClearColor(clear_color[0], clear_color[1], clear_color[2], clear_color[3]);
        glDrawBuffer(GL_COLOR_ATTACHMENT0 + attachment);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        if (!was_binded)
        {
            unbindFBO();
        }
    }

    void clearDepth (void)
    {
        bool was_binded = is_binded;
        bind();
        glClear(GL_DEPTH_BUFFER_BIT);
        if (!was_binded)
        {
            unbindFBO();
        }
    }


    void bindAttachment (int attachment, int texture_unit)
    {
        fboTextures[attachment].bind(texture_unit);
    }

    int bindAttachment (int attachment)
    {
        return fboTextures[attachment].bind();
    }

    void unbindAttachments (void)
    {
        for (unsigned int i = 0; i < fboTextures.size(); ++i)
        {
            fboTextures[i].unbind();
        }
    }

    void setInternalFormat (GLenum int_frm)
    {
        internal_format = int_frm;
    }

    void setInputFormat (GLenum in_format)
    {
        format = in_format;
    }

    void setInputType (GLenum in_type)
    {
        pixel_type = in_type;
    }

    void setTextureType (GLenum tex_type)
    {
        texture_type = tex_type;
    }

    Eigen::Vector4f readPixel (int attach,  Eigen::Vector2i pos)
    {
        bool was_binded = is_binded;
        bind();
        glReadBuffer(GL_COLOR_ATTACHMENT0 + attach);
        GLfloat pixel[4];
        glReadPixels(pos[0], pos[1], 1, 1, GL_RGBA, GL_FLOAT, &pixel[0]);
        if (!was_binded)
        {
            unbindFBO();
        }
        Eigen::Vector4f result (pixel[0], pixel[1], pixel[2], pixel[3]);
        return result;
    }

    void readBuffer (int attach_id,  GLfloat **pixels)
    {
        bool was_binded = is_binded;
        if (*pixels == NULL)
        {
                *pixels = new GLfloat[bufferElements()];
        }
        bind();
        glReadBuffer(GL_COLOR_ATTACHMENT0 + attach_id);
        glReadPixels(0, 0, size[0], size[1], GL_RGBA, GL_FLOAT, *pixels);
        if (!was_binded)
        {
            unbindFBO();
        }
    }


    void readBuffer (int attach_id,  GLbyte ** pixels)
    {
        bool was_binded = is_binded;
        if (*pixels == NULL)
        {
                *pixels = new GLbyte[bufferElements()];
        }
        bind();
        glReadBuffer(GL_COLOR_ATTACHMENT0 + attach_id);
        glReadPixels(0, 0, size[0], size[1], GL_RGBA, GL_UNSIGNED_BYTE, *pixels);
        if (!was_binded)
        {
            unbindFBO();
        }
    }


    void readBuffer (int attach_id,  unsigned char ** pixels)
    {
        bool was_binded = is_binded;
        if (*pixels == NULL)
        {
                *pixels = new unsigned char[bufferElements()];
        }
        bind();
        glReadBuffer(GL_COLOR_ATTACHMENT0 + attach_id);
        glReadPixels(0, 0, size[0], size[1], GL_RGBA, GL_UNSIGNED_BYTE, *pixels);
        if (!was_binded)
        {
            unbindFBO();
        }
    }


    void readBuffer (int attach_id, vector<unsigned char>& pixels)
    {
        bool was_binded = is_binded;
        pixels.clear();
        pixels.resize(bufferElements());
        bind();
        glReadBuffer(GL_COLOR_ATTACHMENT0 + attach_id);
        glReadPixels(0, 0, size[0], size[1], GL_RGBA, GL_UNSIGNED_BYTE, &pixels[0]);
        if (!was_binded)
        {
            unbindFBO();
        }
    }

    void readBuffer (int attach_id, vector<float>& pixels)
    {
        bool was_binded = is_binded;
        pixels.clear();
        pixels.resize(bufferElements(), 0.0);
        bind();
        glFinish();
        glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
        glReadBuffer(GL_COLOR_ATTACHMENT0 + attach_id);
        glReadPixels(0, 0, size[0], size[1], GL_RGBA, GL_FLOAT, &pixels[0]);
        if (!was_binded)
        {
            unbindFBO();
        }
    }

        void readDepthBuffer (vector<GLbyte> &depth_values)
        {
                depth_values.clear();
                depth_values.resize(depthBufferElements());
                glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
                glBindRenderbuffer(GL_RENDERBUFFER, *depthbufferID_sptr);
                glReadPixels(0, 0, size[0], size[1], GL_DEPTH_COMPONENT, GL_BYTE, &depth_values[0]);
                glBindRenderbuffer(GL_RENDERBUFFER, 0);
        }

    void readDepthBuffer (vector<float> & depth_values)
    {
        depth_values.clear();
        depth_values.resize(depthBufferElements());
        glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
        glBindRenderbuffer(GL_RENDERBUFFER, *depthbufferID_sptr);
        glReadPixels(0, 0, size[0], size[1], GL_DEPTH_COMPONENT, GL_FLOAT, &depth_values[0]);
        glBindRenderbuffer(GL_RENDERBUFFER, 0);
    }

        void saveAsPPM (string filename, int attach = 0)
        {
                ofstream out_stream;
                out_stream.open(filename.c_str());
                out_stream << "P3\n";
                out_stream << size[0] << " " << size[1] << "\n";
                out_stream << "255\n";

        bool was_binded = is_binded;

        GLfloat * pixels = new GLfloat[(int)(size[0]*size[1]*4)];
        bind();
        glReadBuffer(GL_COLOR_ATTACHMENT0+attach);
        glReadPixels(0, 0, size[0], size[1], GL_RGBA, GL_FLOAT, pixels);

                int pos;
            for (int j = size[1]-1; j >= 0; --j)
        {
            for (int i = 0 ; i < size[0]; ++i)
            {
                pos = (i + size[0]*j)*4;
                                out_stream << (int)(255*pixels[pos+0]) << " " << (int)(255*pixels[pos+1]) << " " << (int)(255*pixels[pos+2]) << " ";
                        }
                        out_stream << "\n";
                }
                out_stream.close();

            if (!was_binded)
        {
            unbindFBO();
        }
                delete [] pixels;

        }

    void printBuffer (int attach, Eigen::Vector4f exception = Eigen::Vector4f(0.0,0.0,0.0,0.0) )
    {
        bool was_binded = is_binded;

        GLfloat * pixels = new GLfloat[(int)(size[0]*size[1]*4)];
        bind();
        glReadBuffer(GL_COLOR_ATTACHMENT0+attach);
        glReadPixels(0, 0, size[0], size[1], GL_RGBA, GL_FLOAT, pixels);

        int count = 0;
        Eigen::Vector4f min = Eigen::Vector4f::Constant(numeric_limits<float>::max());
        Eigen::Vector4f max = Eigen::Vector4f::Constant (numeric_limits<float>::min());

        int pos;
        Eigen::Vector4f pixel;
        for (int j = 0; j < size[1]; ++j)
        {
            for (int i = 0 ; i < size[0]; ++i)
            {
                pos = (i + size[0]*j)*4;
                pixel << pixels[pos+0], pixels[pos+1], pixels[pos+2], pixels[pos+3];
                if (pixel != exception)
                {
                    cout << "(" << i << "," << j << ") = [ " << pixel.transpose() << " ]" << endl;
                    count++;

                    for (int k = 0; k < 4; ++k)
                    {
                        if (pixel[k] < min[k])
                        {
                            min[k] = pixel[k];
                        }
                        if (pixel[k] > max[k])
                        {
                            max[k] = pixel[k];
                        }
                    }
                }
            }
        }
        delete [] pixels;

        if (!was_binded)
        {
            unbindFBO();
        }

        cout << endl << "info : " << endl;
        cout << "num valid pixels : " << count << endl;
        cout << "min values : " << min.transpose() << endl;
        cout << "max values : " << max.transpose() << endl;
        cout << "tex id : " << attach << endl;
    }


    GLuint getID (void)
    {
        return fbo_id;
    }

    Eigen::Vector2i getDimensions (void)
    {
        return size;
    }

    int getWidth (void)
    {
        return size[0];
    }

    int getHeight (void) {
        return size[1];
    }

    int getNumAttachments (void) {
        return fboTextures.size();
    }

    bool isBinded (void)
    {
        return is_binded;
    }

protected:

    virtual void createFramebuffer (int viewportWidth, int viewportHeight, int numberOfTextures = 1)
    {
        is_binded = false;
        // update dimensions
        size << viewportWidth, viewportHeight;

        bind();

        // clearing textures that already exist
        fboTextures.clear();

        //Creating texture:
        fboTextures.resize( numberOfTextures );
        for (int i = 0; i < numberOfTextures; ++i)
        {
            createTexture(i);
        }

        //Depth Buffer Generation:
        glBindRenderbuffer(GL_RENDERBUFFER, *depthbufferID_sptr);
        if (num_samples == 1)
        {
            glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, size[0], size[1]);
        }
        else
        {
            glRenderbufferStorageMultisample(GL_RENDERBUFFER, num_samples, GL_DEPTH_COMPONENT, size[0], size[1]);
        }
        glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, *depthbufferID_sptr);

        GLint status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
        if (status != GL_FRAMEBUFFER_COMPLETE)
        {
            std::cout << "FBO ERROR : " << status << std::endl;
        }

        unbind();

        //errorCheckFunc(__FILE__, __LINE__);
    }

    virtual void createTexture (int attach_id)
    {
        fboTextures[attach_id].setNumSamples(num_samples);
        
        fboTextures[attach_id].create(texture_type, internal_format, size[0], size[1], format, pixel_type);

        glBindTexture(texture_type, fboTextures[attach_id].texID());
        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0+attach_id, texture_type, fboTextures[attach_id].texID() , 0);
        glBindTexture(texture_type, 0);
    }

};




}
#endif