Eigene Dateien/Vis/src/VFramebufferObject.cpp

Go to the documentation of this file.

#include "VFramebufferObject.h"
#include "glew.h"
#include "IL/il.h"
#include "IL/ilu.h"
#include "IL/ilut.h"
#include <vector>

bool VFramebufferObject::m_ProgramLoaded = false;

VProgram VFramebufferObject::m_RenderToScreen;

VFramebufferObject::VFramebufferObject(int width, int height, unsigned int texturetype) : 
                m_FboHandle(0), m_TextureHandle(0), m_RenderBufferHandle(0), m_TextureType(texturetype)
{
        if (!GLEW_ARB_texture_non_power_of_two)
        {
                m_Width = getNextPowerOfTwo(width);
                m_Height = getNextPowerOfTwo(height);
        }
        else
        {
                m_Width = width;
                m_Height = height;
        }
}

void VFramebufferObject::checkFramebufferObjectStatus()
{
        int error = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
        if (!(error == GL_FRAMEBUFFER_COMPLETE_EXT))
        {
                std::cout << "FBO Error" << gluErrorString(error) << std::endl;;
        }
}

bool VFramebufferObject::devIlInitialised = false;

bool VFramebufferObject::initialiseDevIl()
{
        ilInit();
        iluInit();
        ilutInit();
        ilutRenderer(ILUT_OPENGL);
        if ((ilGetInteger(IL_VERSION_NUM) < IL_VERSION) ||
                (iluGetInteger(ILU_VERSION_NUM) < ILU_VERSION) ||
                (ilutGetInteger(ILUT_VERSION_NUM) < ILUT_VERSION)) 
        {
                std::cout << "devil not working" << std::endl;
                return false;
        }
        return true;
}

VProgram * VFramebufferObject::getRenderToScreenProgram()
{
        if(!m_ProgramLoaded)
        {
                m_RenderToScreen = VProgram(VVertexShader("shader/rendertoscreen_vertex.glsl"), VFragmentShader("shader/rendertoscreen_fragment.glsl"));
                m_ProgramLoaded = true;
        }

        return &m_RenderToScreen;
}


void VFramebufferObject::init()
{
        int mMaxColorTargets;
        glGetIntegerv(GL_MAX_COLOR_ATTACHMENTS_EXT, &mMaxColorTargets);

        //std::cout << "max color targets: " << mMaxColorTargets << std::endl;

        glGenTextures(1, &m_TextureHandle);
        glBindTexture(GL_TEXTURE_2D, m_TextureHandle);

        unsigned int format;
        if(m_TextureType == GL_RGBA16F_ARB)
        {
                if (!GLEW_ARB_texture_float)
                {
                        m_TextureType = GL_RGBA;
                        format = GL_UNSIGNED_SHORT;
                }
                else
                {
                        format = GL_FLOAT;
                }
        }
        else
        {
                format = GL_UNSIGNED_BYTE;
        }

        glTexImage2D(GL_TEXTURE_2D, 0, m_TextureType/*GL_RGBA16F_ARB*/,  m_Width, m_Height, 0, GL_RGBA, format, 0);
        //glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, m_Width, m_Height, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);

        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        //glGenerateMipmapEXT(GL_TEXTURE_2D);

        glGenRenderbuffersEXT(1, &m_RenderBufferHandle);
        glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, m_RenderBufferHandle);
        glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, m_Width, m_Height);


        glGenFramebuffersEXT(1, &m_FboHandle);
        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_FboHandle);
        glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, m_TextureHandle, 0);
        glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_RenderBufferHandle);

        checkFramebufferObjectStatus();

        glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, 0);
        glFramebufferTexture2DEXT( GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, 0, 0 );
        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
        glDrawBuffer(GL_BACK);
        checkFramebufferObjectStatus();

        if(!m_ProgramLoaded)
        {
                m_RenderToScreen = VProgram(VVertexShader("shader/rendertoscreen_vertex.glsl"), VFragmentShader("shader/rendertoscreen_fragment.glsl"));
                m_ProgramLoaded = true;
        }
        

}

void VFramebufferObject::destroy()
{
        if(m_FboHandle!= 0)
        {
                glDeleteFramebuffersEXT(1, &m_FboHandle);
                m_FboHandle = 0;
                glDeleteRenderbuffersEXT(1, &m_RenderBufferHandle);
                m_RenderBufferHandle = 0;
        }
}

void VFramebufferObject::bind()
{
        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_FboHandle);
        glPushAttrib(GL_VIEWPORT_BIT | GL_COLOR_BUFFER_BIT);
        glViewport(0, 0, m_Width, m_Height);
        glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, m_TextureHandle, 0);
        glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_RenderBufferHandle);
        //glGenerateMipmapEXT(GL_TEXTURE_2D);
        glDrawBuffer(GL_COLOR_ATTACHMENT0_EXT);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);     // Clear Screen And Depth Buffer
        checkFramebufferObjectStatus();
}

void VFramebufferObject::unbind()
{
        glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, 0);
        glFramebufferTexture2DEXT( GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, 0, 0 );
        glPopAttrib();
        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
        checkFramebufferObjectStatus();
        glDrawBuffer(GL_BACK);

}

void VFramebufferObject::saveImage(std::string filename)
{
        if(!devIlInitialised)
        {
                devIlInitialised = initialiseDevIl();
        }
        
        glEnable(GL_TEXTURE_2D);
        glBindTexture(GL_TEXTURE_2D, m_TextureHandle);

        std::vector<unsigned char> imagedata;

        imagedata.resize(m_Height * m_Width * 4);
        glPixelStoref(GL_UNPACK_ALIGNMENT, 1);

        glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, &imagedata[0]);

        const GLenum glError = glGetError();

        if (glError != GL_NO_ERROR)
                std::cout << "OpenGL Error saving Image " << gluErrorString(glError) << std::endl;

        ILuint ImageName;
        ilGenImages(1, &ImageName);
        ilBindImage(ImageName);

        ilTexImage(m_Width, m_Height, 1, 4, IL_RGBA, IL_UNSIGNED_BYTE, &imagedata[0]);
        
        ilEnable(IL_FILE_OVERWRITE);
        ilSaveImage(filename.c_str());
        ILenum Error;
        Error = ilGetError();

        if(Error != IL_NO_ERROR)
                std::cout << "DevIl Error saving IMage " << iluErrorString(Error) << std::endl;

        ilDeleteImages(1, &ImageName);

        glBindTexture(GL_TEXTURE_2D, 0);
        glDisable(GL_TEXTURE_2D);
}

void VFramebufferObject::renderToFullScreen()
{
        glActiveTextureARB(GL_TEXTURE0_ARB);
        glEnable(GL_TEXTURE_2D);
        glBindTexture(GL_TEXTURE_2D, this->getTextureHandle());

        m_RenderToScreen.bind();

        glUniform1i(m_RenderToScreen.getUniformLocation("mTexture"),0);

        glBegin(GL_QUADS);
        glTexCoord2f(0.0f, 0.0f);
        glVertex3f(-1.0f, -1.0f, 0.0);

        glTexCoord2f(0.0f, 1.0f);
        glVertex3f(-1.0f, 1.0f, 0.0);

        glTexCoord2f(1.0f, 1.0f);
        glVertex3f(1.0f, 1.0f, 0.0);

        glTexCoord2f(1.0f, 0.0f);
        glVertex3f(1.0f, -1.0f, 0.0);
        glEnd();

        m_RenderToScreen.release();

        glActiveTextureARB(GL_TEXTURE0_ARB);
        glBindTexture(GL_TEXTURE_2D, 0);
        glDisable(GL_TEXTURE_2D);
}

void VFramebufferObject::renderToLowerLeftQuad()
{
        glActiveTextureARB(GL_TEXTURE0_ARB);
        glEnable(GL_TEXTURE_2D);
        glBindTexture(GL_TEXTURE_2D, this->getTextureHandle());

        m_RenderToScreen.bind();

        glUniform1i(m_RenderToScreen.getUniformLocation("mTexture"),0);

        glBegin(GL_QUADS);
        glTexCoord2f(0.0f, 0.0f);
        glVertex3f(-1.0f, -1.0f, -0.01f);

        glTexCoord2f(0.0f, 1.0f);
        glVertex3f(-1.0f, -0.5f, -0.01f);

        glTexCoord2f(1.0f, 1.0f);
        glVertex3f(-0.5f, -0.5f, -0.01f);

        glTexCoord2f(1.0f, 0.0f);
        glVertex3f(-0.5f, -1.0f, -0.01f);
        glEnd();

        m_RenderToScreen.release();

        glActiveTextureARB(GL_TEXTURE0_ARB);
        glBindTexture(GL_TEXTURE_2D, 0);
        glDisable(GL_TEXTURE_2D);
}

void VFramebufferObject::renderToLowerRightQuad()
{
        glActiveTextureARB(GL_TEXTURE0_ARB);
        glEnable(GL_TEXTURE_2D);
        glBindTexture(GL_TEXTURE_2D, this->getTextureHandle());

        m_RenderToScreen.bind();

        glUniform1i(m_RenderToScreen.getUniformLocation("mTexture"),0);

        glBegin(GL_QUADS);
        glTexCoord2f(0.0f, 0.0f);
        glVertex3f(0.5f, -1.0f, -0.01f);

        glTexCoord2f(1.0f, 0.0f);
        glVertex3f(1.0f, -1.0f, -0.01f);

        glTexCoord2f(1.0f, 1.0f);
        glVertex3f(1.0f, -0.5f, -0.01f);

        glTexCoord2f(0.0f, 1.0f);
        glVertex3f(0.5f, -0.5f, -0.01f);
        glEnd();

        m_RenderToScreen.release();

        glActiveTextureARB(GL_TEXTURE0_ARB);
        glBindTexture(GL_TEXTURE_2D, 0);
        glDisable(GL_TEXTURE_2D);
}

---