Unerklärlicher OpenGL Fehler im gDEBugger

[Scorcher24]

Moin.
Ich kanns mir nicht erklären. Ich habe jetzt etliche Fehlerabfragen bezüglich in meinen Code eingebaut, aber Visual Studio steigt beim Debuggen nicht aus. Also meldet OpenGL keinen Fehler während der Debug Session.
Im gDEBugger schaut das anders aus. Dort genieriert glGetShaderiv ein GL_INVALID_ENUM. Allerdings verwende ich das Ding nur 1x und laut Spezifikation korrekt.

NLShader* NLShaderLoader::createFromMemory( const char* name, const char* vertex, const char* fragment )
{
	std::string srcVertex(vertex);
	std::string srcFragment(fragment);

	if ( srcVertex.length() != 0 && srcFragment.length() != 0 )
	{
		// Create OpenGL-Handles        
		GLuint hVertex   = glCreateShader(GL_VERTEX_SHADER_ARB);
		GLuint hFragment = glCreateShader(GL_FRAGMENT_SHADER_ARB);

		// Load the source into OpenGL
		const GLchar* pSrcVertex   = static_cast<const GLchar*>(srcVertex.c_str());
		const GLchar* pSrcFragment = static_cast<const GLchar*>(srcFragment.c_str());
		glShaderSource(hVertex, 1, &pSrcVertex, NULL);
		glShaderSource(hFragment, 1, &pSrcFragment, NULL);

		// Compile the Shaders
		glCompileShader(hVertex);        
		glCompileShader(hFragment);

		if ( this->checkShader(name, hVertex) == false || this->checkShader(name, hFragment) == false )
		{
#ifdef _DEBUG
			if ( glGetError() != GL_NO_ERROR )
				throw NLException("GL_ERROR");
#endif
			glDeleteShader(hVertex);
			glDeleteShader(hFragment);
			return NULL;
		}

		// Create Program
		GLuint hProgram  = glCreateProgram();

		// Attach
		glAttachShader(hProgram, hVertex);
		glAttachShader(hProgram, hFragment);

		// Link
		glLinkProgram(hProgram);

		if ( this->checkProgram(name, hProgram) == false)
		{
#ifdef _DEBUG
			if ( glGetError() != GL_NO_ERROR )
				throw NLException("GL_ERROR");
#endif
			glDeleteShader(hVertex);
			glDeleteShader(hFragment);
			return NULL;
		}

		// Detach
		glDetachShader(hProgram, hVertex);
		glDetachShader(hProgram, hFragment);

		glDeleteShader(hVertex);
		glDeleteShader(hFragment);

#ifdef _DEBUG
		if ( glGetError() != GL_NO_ERROR )
			throw NLException("GL_ERROR");
#endif

		NLShader* handle = new NLShader(hProgram, name);
		return handle;
	}
	return NULL;

}

NLShader* NLShaderLoader::create(const char* name, const char* vertex, const char* fragment)
{
	// Load the file
	std::string srcVertex   = this->loadFile(vertex);
	std::string srcFragment = this->loadFile(fragment);

	return this->createFromMemory(name, srcVertex.c_str(), srcFragment.c_str());
}

bool NLShaderLoader::checkShader(const char* name, unsigned int shader)
{
    bool r = true;

	GLint infoLogLength = 1024;
	glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLogLength);
    char* buffer = new char[infoLogLength+1];
    memset(buffer, 0, sizeof(char)*infoLogLength+1);
    int length = 0;

    glGetShaderInfoLog(shader, 1024, &infoLogLength, buffer);
    if ( length > 0 )
    {        
        std::stringstream ss;
        ss << "[Shader:" << name <<":Compiler]: " << buffer;
        int find = ss.str().find("successfully");
        if ( find != std::string::npos )
        {
            NLTrace(ss.str().substr(0, ss.str().size()-2));
			m_event(ss.str().substr(0, ss.str().size()-2));
        }
        else
        {
            NLError(ss.str().substr(0, ss.str().size()-2));
			m_event(ss.str().substr(0, ss.str().size()-2));
            r = false;
        }        
    }
    delete [] buffer;
    return r;
}

bool NLShaderLoader::checkProgram(const char* name, unsigned int program)
{
    bool r = true;
    char* buffer = new char[1024];    
	memset(buffer, 0, sizeof(char)*1024);
    int length = 0;

    glGetProgramInfoLog(program, 1024, &length, buffer);
    if ( length > 0 )
    {
        std::stringstream ss;
        ss << "[Shader:" << name <<":Linker]: " << buffer;
        glValidateProgram(program);
        GLint result;
        glGetProgramiv(program, GL_VALIDATE_STATUS, &result);
        if ( result == GL_FALSE )
        {
            NLError(ss.str().substr(0, ss.str().size()-2));
			m_event(ss.str().substr(0, ss.str().size()-2));
            r = false;
        }
        else
        {
            NLTrace(ss.str().substr(0, ss.str().size()-2));
			m_event(ss.str().substr(0, ss.str().size()-2));
        }
    }
    delete [] buffer;
    return r;
}

Sorry für den langen Code, aber hier soll es angeblich auftreten.

OpenGL Debug Output: API Error, glGetShaderiv parameter <shader> has an invalid value '1': must be a valid shader object name (GL_INVALID_VALUE)

http://h-4.abload.de/img/glerrorjq3e.png

Wenn man hier auf den Callstack schaut, dann sieht man, dass er bei glDeleteShader aussteigt, die Meldung sich aber auf eine andere Funktion bezieht. Die Programmstelle ist mir klar, aber laut VS-Debugger läuft hier alles glatt. Es wird auch soweit alles korrekt angezeigt in meinen Testszenen.
Ich weiss nicht mehr weiter. Ich habs debugged bis zum umfallen, eventuell hat hier noch jemand eine Idee.