bool GLProgram::link()
{
glLinkProgram(m_program);
glValidateProgram(m_program);
GLint status;
glGetProgramiv(m_program, GL_LINK_STATUS, &status);
if (status == GL_FALSE) {
FZLOGERROR("GLProgram: Error linking program: %i.", m_program);
FZLOGERROR("%s", getProgramLog().c_str());
fzGLDeleteProgram( m_program );
m_program = 0;
return false;
}
char uniformName[256];
GLint nuUniforms = 0;
glGetProgramiv(m_program, GL_ACTIVE_UNIFORMS, &nuUniforms);
for(fzInt index = 0; index < nuUniforms; ++index)
{
glGetActiveUniform(m_program, index, 256, NULL, NULL, NULL, uniformName);
m_uniforms.insert(uniformsPair(fzHash(uniformName), glGetUniformLocation(m_program, uniformName)));
}
CHECK_GL_ERROR_DEBUG();
setUniform1i("u_texture", 0);
return true;
}
void Shader::Reload()
{
GLuint vs, fs;
// create ids for our vertex and frag shaders
vs = glCreateShader(GL_VERTEX_SHADER);
fs = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(vs, 1, &vss, NULL);
glShaderSource(fs, 1, &fss, NULL);
glCompileShader(vs);
glCompileShader(fs);
// create program, attach shaders, link.
id = glCreateProgram();
glAttachShader(id, vs);
glAttachShader(id, fs);
glBindAttribLocation(id, VERTEX_ARRAY, "VPos");
glBindAttribLocation(id, NORMAL_ARRAY, "VNor");
glBindAttribLocation(id, COORD_ARRAY, "VCoords");
glLinkProgram(id);
// We're done with these now.
glDetachShader(id, vs);
glDetachShader(id, fs);
glDeleteShader(vs);
glDeleteShader(fs);
// print out shader logs.
std::string log = getShaderLog(vs);
if (!log.empty())
Log->Print("Vertex shader log: %s", log.c_str());
log = getShaderLog(fs);
if (!log.empty())
Log->Print("Fragment shader log: %s", log.c_str());
log = getProgramLog(id);
if (!log.empty())
{
Log->Print("Shader program log: %s", log.c_str());
// XXX
Log->Print("catastrophic shader error. committing suicide.");
exit(2);
}
this->Bind();
}
/**
* Create a GLSL program object from vertex and fragment shader files.
*
* @param vShaderFile The vertex shader filename
* @param fShaderFile The fragment shader filename
* @return handle to the GLSL program
*/
GLuint createGLSLProgram(const char* vertexSource, const char* fragmentSource)
{
GLuint vertexShader;
GLuint fragmentShader;
char* log;
_program = glCreateProgram();
// Create vertex shader
vertexShader = createShader(vertexSource, GL_VERTEX_SHADER);
// Check for compile errors
if(!shaderCompileStatus(vertexShader))
{
log = getShaderLog(vertexShader);
fprintf(stderr, "Could not compile vertex shader:\n%s\n", log);
free(log);
terminate(EXIT_FAILURE);
}
// Create fragment shader
fragmentShader = createShader(fragmentSource, GL_FRAGMENT_SHADER);
// Check for compile errors
if(!shaderCompileStatus(fragmentShader))
{
log = getShaderLog(fragmentShader);
fprintf(stderr, "Could not compile fragment shader:\n%s\n", log);
free(log);
terminate(EXIT_FAILURE);
}
// Attach the shaders to the program
glAttachShader(_program, vertexShader);
glAttachShader(_program, fragmentShader);
// Link the program
glLinkProgram(_program);
// Check for linker errors
if(!programLinkStatus(_program))
{
log = getProgramLog(_program);
fprintf(stderr, "GLSL program filed to link:\n%s\n", log);
free(log);
terminate(EXIT_FAILURE);
}
return _program;
}
GLuint loadProgram(const std::string& vertexShaderPath, const std::string& fragmentShaderPath)
{
GLuint program = glCreateProgram();
GLuint vertexShader = 0;
GLuint fragmentShader = 0;
try
{
vertexShader = loadShader(vertexShaderPath, GL_VERTEX_SHADER);
glAttachShader(program, vertexShader);
fragmentShader = loadShader(fragmentShaderPath, GL_FRAGMENT_SHADER);
glAttachShader(program, fragmentShader);
glLinkProgram(program);
GLint programSuccess = GL_TRUE;
glGetProgramiv(program, GL_LINK_STATUS, &programSuccess);
if (programSuccess != GL_TRUE)
{
throw std::runtime_error(getProgramLog(program));
}
glDeleteShader(vertexShader);
glDeleteShader(fragmentShader);
}
catch (std::exception e)
{
glDeleteProgram(program);
glDeleteShader(vertexShader);
glDeleteShader(fragmentShader);
throw std::runtime_error(e.what());
}
return program;
}
