void GLProgramFactory::assertProgramLinked(GLuint program)
{
// Check the link status
GLint linkStatus;
glGetProgramiv(program, GL_LINK_STATUS, &linkStatus);
if (linkStatus != GL_TRUE)
{
throw std::runtime_error(
"Failed to construct GLSL program:\n"
+ getProgramInfoLog(program)
);
}
#ifdef _DEBUG
// Ask GL to validate the program (this means that it will run)
glValidateProgram(program);
// Get the valid status and info log
GLint validStatus;
glGetProgramiv(program, GL_VALIDATE_STATUS, &validStatus);
std::string validLog = getProgramInfoLog(program);
// Output to console
rConsole() << "[renderer] GLSL program "
<< (validStatus == GL_TRUE ? "IS " : "IS NOT ") << "valid.\n";
rConsole() << "Info:\n" << validLog << std::endl;
#endif
}
const bool GLSLProgram::validate()
{
assert( getProgramObject() != 0 && "Empty glsl program" );
// VALIDATE
glValidateProgram( getProgramObject() );
// CHECK if successfully validated
GLint result = GL_FALSE;
glGetProgramiv( getProgramObject(), GL_VALIDATE_STATUS, &result );
std::string strInfoLog = getProgramInfoLog( getProgramObject() );
if ( isLogInteresting(strInfoLog) )
{
// There is a log
m_linkLog += "Validation log:\n";
m_linkLog += strInfoLog;
if ( result == GL_FALSE )
{
// Message in cerr only if validation fails
std::cerr << " --" << std::endl;
std::cerr << "Program " << getProgramObject() << "not validated :" << std::endl;
std::cerr << strInfoLog << std::endl;
}
}
return result == GL_TRUE;
}
GLuint linkShader(size_t count, ...)
{
// Create program object
GLuint program = glCreateProgram();
if(program == 0) throw GL_Exception("glCreateProgram failed");
// Attach arguments
va_list args;
va_start(args, count);
for(size_t i = 0; i < count; ++i)
{
glAttachShader(program, va_arg(args, GLuint));
}
va_end(args);
// Link program and check for errors
glLinkProgram(program);
std::cout << getProgramInfoLog(program);
int linkStatus;
glGetProgramiv(program, GL_LINK_STATUS, &linkStatus);
if(linkStatus == GL_FALSE) throw std::runtime_error("shader linking failed");
return program;
}
std::string
VSShaderLib::getAllInfoLogs() {
std::string s;
for (int i = 0; i < VSShaderLib::COUNT_SHADER_TYPE; ++i) {
if (pShader[i]) {
getShaderInfoLog((VSShaderLib::ShaderType)i);
s.append(VSShaderLib::spStringShaderTypes[i]);
s.append(": ");
s.append(pResult);
s.append("\n");
//s += VSShaderLib::spStringShaderTypes[i] + ": " + pResult + "\n";
}
}
if (pProgram) {
getProgramInfoLog();
s += "Program: " + pResult;
if (isProgramValid())
s += " - Valid\n";
else
s += " - Not Valid\n";
}
pResult = s;
return pResult;
}
//! Links all attached shader and creates a complete shader program
void Shader::link()
{
int linkStatus;
//link the program
glLinkProgram(id);
// Check validity
glGetProgramiv(id, GL_LINK_STATUS, &linkStatus);
if(linkStatus != GL_TRUE)
{
std::cerr << getProgramInfoLog() << std::endl;
throw std::runtime_error("Unable to link shader program.");
}
}
Program(const vector<shared_ptr<Shader>>& shaders) {
_handle = glCreateProgram();
for(auto& shader : shaders)
glAttachShader(_handle, *shader);
glLinkProgram(_handle);
if (getProgramiv(_handle, GL_LINK_STATUS) == GL_FALSE) {
throw logic_error("failed to link the program:\n" + getProgramInfoLog(_handle));
}
for(auto& shader : shaders)
glDetachShader(_handle, *shader);
}
bool ShaderProgram::link(void)
{
assert(glIsProgram(m_program));
/* link program */
glLinkProgram(m_program);
/* query link status */
GLint status = GL_FALSE;
glGetProgramiv(m_program, GL_LINK_STATUS, &status);
/* print linking log */
std::cerr << "Linking status: " << (status == GL_TRUE ? "succeeded" : "failed") << std::endl;
std::cerr << getProgramInfoLog(m_program) << std::endl;
/* check linking status */
return status != GL_FALSE;
}
GLuint linkProgram(unsigned int count, ...)
{
/* create program object */
GLuint program = glCreateProgram();
if (program == 0)
{
std::cerr << "Failed to create shader program object: "
<< errorToStr(glGetError())
<< std::endl;
return 0;
}
/* attach shaders */
va_list args;
va_start(args, count);
for (unsigned int i = 0; i < count; ++i)
{
glAttachShader(program, va_arg(args, GLuint));
}
va_end(args);
/* link program */
glLinkProgram(program);
/* query link status */
GLint status = GL_FALSE;
glGetProgramiv(program, GL_LINK_STATUS, &status);
/* print linking log */
std::cerr << "Linking status: " << (status == GL_TRUE ? "succeeded" : "failed") << std::endl;
std::cerr << getProgramInfoLog(program) << std::endl;
/* check linking status */
if (status == GL_FALSE)
{
glDeleteProgram(program);
return 0;
}
return program;
}
void LoggedShaderProgramService::checkLinkStatus(GLuint programID) {
auto infoLog = getProgramInfoLog(programID);
m_logService->info("Program Info Log:\n%s\n", infoLog.c_str());
ShaderProgramService::checkLinkStatus(programID);
}
