OpenGL ShaderHandler

ShaderHandler* ShaderHandler::mInstance = new ShaderHandler;

    ShaderHandler::ShaderHandler( void )
    {
        initialize();
    }

    ShaderHandler::~ShaderHandler( void )
    {
        if( mPrograms )
        {
            mPrograms->clear();
            delete mPrograms;
        }

        if( mShaders )
        {
            mShaders->clear();
            delete mShaders;
        }

        if( mInstance ) delete mInstance;
    }

    void ShaderHandler::compileAndLink( void )
    {
        GLuint program = glCreateProgram();

        if( !program ) Debug::Log::error( "ShaderHandler::compileAndLink could not create program!" );

        const size_t sSize = mShaders->size();

        size_t iShaders = 0;

        for( ; iShaders < sSize; ++iShaders )
        {
            glAttachShader( program, ( *mShaders )[ iShaders ] );
        }

        glLinkProgram( program );

        GLint success;

        glGetProgramiv( program, GL_LINK_STATUS, &success );

        if( !success )
        {
            GLint len;

            glGetProgramiv( program, GL_INFO_LOG_LENGTH, &len );

            GLsizei bufsize = len + 1;

            char* log = new char[ bufsize ];

            glGetProgramInfoLog( program, bufsize, NULL, log );

            Debug::Log::error( "OpenGL Says: \n \t %s", log );
        }

        mPrograms->push_back( program );
    }

    void ShaderHandler::clear( void )
    {
        mShaders->clear();
        mPrograms->clear();
    }

    void ShaderHandler::createShaders( QVector< Shader > &shaders )
    {
        QVectorIterator< Shader > iShaders( shaders );

        while( iShaders.hasNext() )
        {
            Shader s = iShaders.next();

            if( !s.Source ) continue;

            GLuint shaderMem = glCreateShader( s.Type );

            if( !shaderMem )
            {
                Debug::Log::error( "Cannot create shader memory in ShaderHandler::createShaders for GPU is out of memory." );
            }

            glShaderSource( shaderMem, 1, &s.Source, NULL );
            glCompileShader( shaderMem );

            mShaders->push_back( shaderMem );
        }
    }

    void ShaderHandler::initialize( void )
    {
        mShaders = new QVector< GLuint >;
        mPrograms = new QVector< GLuint >;
    }

    Shader ShaderHandler::getShader( const char* name, const char* filepath, GLenum type )
    {
        QString shader = FileUtility::readShader( filepath );

        Shader s;

        s.Source = shader.toStdString().c_str();
        s.Type = type;
        s.Name = name;
        s.SourceLen = shader.size();

        Debug::Log::info( "Shader Source %s", s.Source );

        return s;
    }