Eigene Dateien/FlowVis/src/VProgram.cpp

Go to the documentation of this file.

#include "VProgram.h"
#include "glew.h"

void VProgram::attach(const VShader &shaShader)
{
        if (m_uProgram)
        {
                bool bAttached = false;

                for (std::list<VShader>::const_iterator i = m_lisShaders.begin(); i != m_lisShaders.end(); i++)
                {
                        if ((*i).GetObject() == shaShader.GetObject())
                        {
                                bAttached = true;
                                break;
                        }
                }

                if (!bAttached)
                {
                        glAttachObjectARB(m_uProgram, shaShader.GetObject());
                        GLenum glError = glGetError();

                        if (glError != GL_NO_ERROR)
                                std::cout << "Error attaching shader " << gluErrorString(glError) << std::endl;

                        m_lisShaders.push_back(shaShader);
                        shaShader.attach();

                        link();
                }
        }
}

void VProgram::detach(const VShader & shaShader)
{
        if (m_uProgram)
        {
                std::list<VShader>::iterator iteShader = m_lisShaders.end();

                for (std::list<VShader>::iterator i = m_lisShaders.begin(); i != m_lisShaders.end(); i++)
                {
                        if ((*i).GetObject() == shaShader.GetObject())
                        {
                                iteShader = i;
                                break;
                        }
                }

                if (iteShader != m_lisShaders.end())
                {
                        glDetachObjectARB(m_uProgram, shaShader.GetObject());
                        GLenum glError = glGetError();

                        if (glError != GL_NO_ERROR)
                                std::cout << "Error detaching shader "  << gluErrorString(glError) << std::endl;

                        m_lisShaders.erase(iteShader);
                        shaShader.detach();

                        link();
                }
        }
}

void VProgram::bind()
{
        if (m_uProgram)
        {
                glUseProgramObjectARB(m_uProgram);
                const GLenum glError = glGetError();

                if (glError != GL_NO_ERROR)
                        std::cout << "Error binding program " << gluErrorString(glError) << std::endl;
        }
}

void VProgram::release()
{
        if (m_uProgram)
        {
                glUseProgramObjectARB(0);
                const GLenum glError = glGetError();

                if (glError != GL_NO_ERROR)
                        std::cout << "Error releasing program "  << gluErrorString(glError) << std::endl;
        }
}

const int VProgram::getUniformLocation(const std::string & strName) const
{
        int iLocation = -1;

        if (m_uProgram)
        {
                iLocation = glGetUniformLocationARB(m_uProgram,strName.c_str()); 
                const GLenum glError = glGetError();

                if (glError != GL_NO_ERROR)
                        std::cout << "Error retrieving location "  << gluErrorString(glError) << std::endl;
        }

        return iLocation;
}

const int VProgram::getAttributeLocation(const std::string & strName) const
{
        int iLocation = -1;

        if (m_uProgram)
        {
                iLocation = glGetAttribLocationARB(m_uProgram,strName.c_str()); 
                const GLenum glError = glGetError();

                if (glError != GL_NO_ERROR)
                        std::cout << "Error retrieving location "  << gluErrorString(glError) << std::endl;
        }

        return iLocation;
}

void VProgram::link()
{
        if (m_uProgram)
        {
                glLinkProgramARB(m_uProgram);
                const GLenum glError = glGetError();

                if (glError != GL_NO_ERROR)
                        std::cout << "Error linking program " << gluErrorString(glError) << std::endl;

                int iReturn = 1;
                glGetObjectParameterivARB(m_uProgram,GL_OBJECT_LINK_STATUS_ARB,&iReturn);

                if (!iReturn)
                {
                        int iLength = 0;

                        glGetObjectParameterivARB(m_uProgram, GL_OBJECT_INFO_LOG_LENGTH_ARB,&iLength);

                        char *pInfo = new char[iLength];
                        int iWritten = 0;

                        glGetInfoLogARB(m_uProgram, iLength, &iWritten, pInfo);
                        std::string strInfo(pInfo);
                        delete[] pInfo;

                        std::cout << "Error linking program\n\n" << strInfo.c_str() << std::endl;
                }
        }
}

void VProgram::initialize()
{
        if (!GLEW_ARB_shader_objects)
                std::cout << "GL_ARB_shader_objects is not supported" << std::endl;

        if (!m_uProgram)
        {
                m_uProgram = glCreateProgramObjectARB();
                const GLenum glError = glGetError();

                if (glError != GL_NO_ERROR)
                        std::cout << "Error creating program " << gluErrorString(glError) << std::endl;
        }
}

void VProgram::uninitialize()
{
        if (m_uProgram)
        {
                for (std::list<VShader>::const_iterator i = m_lisShaders.begin(); i != m_lisShaders.end(); i++)
                {
                        glDetachObjectARB(m_uProgram, (*i).GetObject());
                        const GLenum glError = glGetError();

                        if (glError != GL_NO_ERROR)
                                std::cout << "Error detaching shader " << gluErrorString(glError) << std::endl;

                        (*i).detach();
                }

                m_lisShaders.clear();
                
                glDeleteObjectARB(m_uProgram);
                const GLenum glError = glGetError();

                if (glError != GL_NO_ERROR)
                        std::cout << "Error deleting program " << gluErrorString(glError) << std::endl;
        }
}

---