GLuint Shaders::loadShaderFromString(const std::string& vertexSourceCode, const std::string& fragmentSourceCode)
{
// Create the shaders
GLuint vertexShaderID = glCreateShader(GL_VERTEX_SHADER);
GLuint fragmentShaderID = glCreateShader(GL_FRAGMENT_SHADER);
GLint result = GL_FALSE;
int infoLogLength;
compileShader(vertexShaderID, vertexSourceCode, &result, &infoLogLength);
compileShader(fragmentShaderID, fragmentSourceCode, &result, &infoLogLength);
// Link the program
GLuint programID = glCreateProgram();
glAttachShader(programID, vertexShaderID);
glAttachShader(programID, fragmentShaderID);
glLinkProgram(programID);
// Check the program
glGetProgramiv(programID, GL_LINK_STATUS, &result);
glGetProgramiv(programID, GL_INFO_LOG_LENGTH, &infoLogLength);
if ( infoLogLength > 0 ){
std::vector<char> programErrorMessage(infoLogLength+1);
glGetProgramInfoLog(programID, infoLogLength, NULL, &programErrorMessage[0]);
printf("%s\n", &programErrorMessage[0]);
}
glDeleteShader(vertexShaderID);
glDeleteShader(fragmentShaderID);
return programID;
}
GLuint Shaders::createShaderProgram(const std::string &vertexShaderCode, const std::string &fragmentShaderCode)
{
GLuint vertexHandle = compileShaderCode(vertexShaderCode, GL_VERTEX_SHADER);
GLuint fragmentHandle = compileShaderCode(fragmentShaderCode, GL_FRAGMENT_SHADER);
GLuint programHandle = glCreateProgram();
glAttachShader(programHandle, vertexHandle);
glAttachShader(programHandle, fragmentHandle);
glLinkProgram(programHandle);
GLint result = GL_FALSE;
int infoLength;
glGetProgramiv(programHandle, GL_LINK_STATUS, &result);
glGetProgramiv(programHandle, GL_INFO_LOG_LENGTH, &infoLength);
if (infoLength > 0) {
std::vector<char> programErrorMessage(infoLength + 1);
glGetProgramInfoLog(programHandle, infoLength, NULL, &programErrorMessage[0]);
std::cout << "Error linking program: " << &programErrorMessage[0] << std::endl;
} else {
std::cout << "Shader program linking successful" << std::endl;
}
glDetachShader(programHandle, vertexHandle);
glDetachShader(programHandle, fragmentHandle);
glDeleteShader(vertexHandle);
glDeleteShader(fragmentHandle);
return programHandle;
}
ProgramGLSL::ProgramGLSL(std::string _name, std::string _vsPath, std::string _gsPath, std::string _fsPath)
{
name = _name;
//1. insert VS
vertexShaderIndex = insertVertexShader(_vsPath);
//2. insert GS
geometryShaderIndex = insertGeometryShader(_gsPath);
//3. insert Fs
fragmentShaderIndex = insertFragmentShader(_fsPath);
//4. create program
fprintf(stdout, "Creating Program\n");
programID = glCreateProgram();
//5. Attach shaders
if(vertexShaderIndex >= 0)
{
printf("Attaching vertexshader %i to the %s technique.\n", vertexShaderIndex, name.c_str());
glAttachShader(programID, vertexShaderIndex);
}
if(geometryShaderIndex >= 0)
{
printf("Attaching geometryshader %i to the %s technique.\n", geometryShaderIndex, name.c_str());
glAttachShader(programID, geometryShaderIndex);
}
if(fragmentShaderIndex >= 0)
{
printf("Attaching fragmentshader %i to the %s technique.\n", fragmentShaderIndex, name.c_str());
glAttachShader(programID, fragmentShaderIndex);
}
//6. link program
fprintf(stdout, "Linking Program\n");
glLinkProgram(programID);
GLint result = GL_FALSE;
int infoLogLength;
//7. check program
glGetProgramiv(programID, GL_LINK_STATUS, &result);
glGetProgramiv(programID, GL_INFO_LOG_LENGTH, &infoLogLength);
std::vector<char> programErrorMessage(_max(infoLogLength, int(1)));
glGetShaderInfoLog(programID, infoLogLength, NULL, &programErrorMessage[0]);
fprintf(stdout, "Program Message: %s\n", &programErrorMessage[0]);
if(result == GL_FALSE)
{
printf("something wrong with program: %s\n\n", name.c_str());
}
else
{
printf("Successfully linked program: %s\n\n", name.c_str());
}
//Maybe delete shaders
}
unsigned int
ShaderProgram::linkProgram()
{
if (!checkBuilt()) {
// this ShaderProgram has already been built.
return 0;
}
if (m_stages.empty()) {
Err() << "When linking program, there were no shaders to link! Cannot "
"create shader program.";
return 0;
}
if (m_programId != 0) {
Dbg() << "Relinking shader program id=" << m_programId;
} else {
// have GL make a program and bail out if no success.
createNewProgram();
if (m_programId == 0)
return 0;
Dbg() << "Linking shader program id=" << m_programId;
}
gl_check(glLinkProgram(m_programId));
// Check the program
int InfoLogLength{ 0 };
GLint result{ GL_FALSE };
gl_check(glGetProgramiv(m_programId, GL_LINK_STATUS, &result));
gl_check(glGetProgramiv(m_programId, GL_INFO_LOG_LENGTH, &InfoLogLength));
Dbg() << "GL Link Status for shader program "
<< m_programId << ": "
<< (result == GL_FALSE ? "GL_FALSE" : "GL_TRUE")
<< ".";
if (InfoLogLength > 1) {
std::vector<char> programErrorMessage(InfoLogLength + 1);
gl_check(glGetProgramInfoLog(m_programId,
InfoLogLength,
nullptr,
&programErrorMessage[0]));
Dbg() << &programErrorMessage[0];
}
return m_programId;
}
void Shader::buildProgram(GLuint programLoc, GLuint *shaders, int numShaders) {
// Link the program
for (int i = 0; i < numShaders; i++) {
glAttachShader(programLoc, shaders[i]);
}
glLinkProgram(programLoc);
// Check the program
GLint Result = GL_FALSE;
int InfoLogLength;
glGetProgramiv(programLoc, GL_LINK_STATUS, &Result);
glGetProgramiv(programLoc, GL_INFO_LOG_LENGTH, &InfoLogLength);
std::vector<char> programErrorMessage(std::max(InfoLogLength, int(1)));
glGetProgramInfoLog(programLoc, InfoLogLength, NULL, &programErrorMessage[0]);
if (!Result)
LOG_ERROR(logger) << &programErrorMessage[0];
}
GreBeginNamespace
OpenGlHardwareProgram::OpenGlHardwareProgram(const std::string& name, const HardwareShader& vs, const HardwareShader& fs)
: HardwareProgramPrivate(name, vs, fs), _mProgramId(0), _mLinked(false)
{
if(!vs.expired() && !fs.expired())
{
GLuint vsid = *((const GLuint*)(vs.getCustomData("OpenGlId")));
GLuint fsid = *((const GLuint*)(fs.getCustomData("OpenGlId")));
#ifdef GreIsDebugMode
GreDebugPretty() << "Linking Program '" << name << "'." << std::endl;
#endif
_mProgramId = glGlobalContext->getGl().CreateProgram();
glGlobalContext->getGl().AttachShader(_mProgramId, vsid);
glGlobalContext->getGl().AttachShader(_mProgramId, fsid);
glGlobalContext->getGl().LinkProgram(_mProgramId);
GLint result = GL_FALSE; int infoLogLenght;
glGlobalContext->getGl().GetProgramiv(_mProgramId, GL_LINK_STATUS, &result);
glGlobalContext->getGl().GetProgramiv(_mProgramId, GL_INFO_LOG_LENGTH, &infoLogLenght);
if(infoLogLenght > 0) {
std::vector<char> programErrorMessage(infoLogLenght+1);
glGlobalContext->getGl().GetProgramInfoLog(_mProgramId, infoLogLenght, NULL, &programErrorMessage[0]);
GreDebugPretty() << "Glsl Linker Error : " << &programErrorMessage[0] << std::endl;
}
glGlobalContext->getGl().DetachShader(_mProgramId, vsid);
glGlobalContext->getGl().DetachShader(_mProgramId, fsid);
if(result == GL_TRUE)
_mLinked = true;
else
_mLinked = false;
}
#ifdef GreIsDebugMode
else
{
GreDebugPretty() << "Tried to create OpenGlHardwareProgram without vertex/fragment shader." << std::endl;
}
#endif
}
GLuint ShaderProgram::linkProgram(GLuint vertShader, GLuint fragShader) {
GLint compileResult = GL_FALSE;
int infoLogLength;
GLuint program = glCreateProgram();
glAttachShader(program, vertShader);
glAttachShader(program, fragShader);
glLinkProgram(program);
glGetProgramiv(program, GL_LINK_STATUS, &compileResult);
if(compileResult == GL_FALSE) {
glGetProgramiv(program, GL_INFO_LOG_LENGTH, &infoLogLength);
std::vector<char> programErrorMessage(std::max(infoLogLength, int(1)));
glGetProgramInfoLog(program, infoLogLength, NULL, &programErrorMessage[0]);
throw ShaderException(std::string("Error linking shader program: ") + &programErrorMessage[0]);
}
return program;
}
GLboolean Program::linkProgram()
{
//link the program
std::cout << clog::inf << "Linking program..." << std::endl;
glLinkProgram(instance);
GLint result = GL_FALSE;
GLint infoLogLength;
//check the program
glGetProgramiv(instance, GL_LINK_STATUS, &result);
glGetProgramiv(instance, GL_INFO_LOG_LENGTH, &infoLogLength);
if(infoLogLength > 0)
{
std::vector<char> programErrorMessage(infoLogLength + 1);
glGetProgramInfoLog(instance, infoLogLength, NULL, &programErrorMessage[0]);
std::cerr << clog::err << &programErrorMessage[0] << std::endl;
}
return GL_TRUE;
}
void OpenGlHardwareProgram::finalize()
{
if(!_mProgramId)
{
_mProgramId = glGlobalContext->getGl().CreateProgram();
}
if(_mProgramId)
{
GLuint vsid = *(GLuint*)(_mVertexShader.getCustomData("OpenGlId"));
GLuint fsid = *(GLuint*)(_mFragmentShader.getCustomData("OpenGlId"));
glGlobalContext->getGl().AttachShader(_mProgramId, vsid);
glGlobalContext->getGl().AttachShader(_mProgramId, fsid);
glGlobalContext->getGl().LinkProgram(_mProgramId);
GLint result = GL_FALSE;
int infoLogLenght;
glGlobalContext->getGl().GetProgramiv(_mProgramId, GL_LINK_STATUS, &result);
glGlobalContext->getGl().GetProgramiv(_mProgramId, GL_INFO_LOG_LENGTH, &infoLogLenght);
if(infoLogLenght > 0) {
std::vector<char> programErrorMessage(infoLogLenght+1);
glGlobalContext->getGl().GetProgramInfoLog(_mProgramId, infoLogLenght, NULL, &programErrorMessage[0]);
GreDebugPretty() << "Glsl Linker Error : " << &programErrorMessage[0] << std::endl;
}
glGlobalContext->getGl().DetachShader(_mProgramId, vsid);
glGlobalContext->getGl().DetachShader(_mProgramId, fsid);
if(result == GL_TRUE)
_mLinked = true;
else
_mLinked = false;
}
}
/// <summary>
/// Loads the program, empty strings in the config are not loaded or linked shader stages.
/// There are no errors for incomplete programs.
/// </summary>
/// <param name="programName">Name of the program.</param>
/// <param name="config">The configuration.</param>
/// <param name="uniSlots">The uniform buffer slots.</param>
/// <returns></returns>
const ShaderProgram* ShaderProgram::LoadProgram( const std::string& programName, const InitConfig& config,
const std::unordered_map<std::string, uint32_t>& uniSlots )
{
// Check if the shader already exists
ShaderProgram* sp = AppManager::GetScene()->GetShader( programName );
if( sp != nullptr)
return sp;
// Create the program
sp = new ShaderProgram();
sp->config = config;
sp->programID = glCreateProgram();
// Load and attach all the shaders
GLuint vshader = 0;
GLuint tcshader = 0;
GLuint teshader = 0;
GLuint gshader = 0;
GLuint fshader = 0;
GLuint cshader = 0;
if( !config.vsPath.empty() )
{
vshader = sp->LoadShader( config.vsPath, GL_VERTEX_SHADER );
glAttachShader( sp->programID, vshader );
}
if( !config.tcsPath.empty() )
{
tcshader = sp->LoadShader( config.tcsPath, GL_TESS_CONTROL_SHADER );
glAttachShader( sp->programID, tcshader );
}
if( !config.tesPath.empty() )
{
teshader = sp->LoadShader( config.tesPath, GL_TESS_EVALUATION_SHADER );
glAttachShader( sp->programID, teshader );
}
if( !config.gsPath.empty() )
{
gshader = sp->LoadShader( config.gsPath, GL_GEOMETRY_SHADER );
glAttachShader( sp->programID, gshader );
}
if( !config.fsPath.empty() )
{
fshader = sp->LoadShader( config.fsPath, GL_FRAGMENT_SHADER );
glAttachShader( sp->programID, fshader );
}
if( !config.csPath.empty() )
{
cshader = sp->LoadShader( config.csPath, GL_COMPUTE_SHADER );
glAttachShader( sp->programID, cshader );
}
// Link program
glLinkProgram( sp->programID );
// Check the program
GLint result = GL_FALSE;
int infoLogLength;
glGetProgramiv( sp->programID, GL_LINK_STATUS, &result );
glGetProgramiv( sp->programID, GL_INFO_LOG_LENGTH, &infoLogLength );
std::vector<char> programErrorMessage( std::max( infoLogLength, int( 1 ) ) );
glGetProgramInfoLog( sp->programID, infoLogLength, NULL, &programErrorMessage[0] );
Debug::Log( trim( std::string( programErrorMessage.begin(), programErrorMessage.end() ) ), LogType::Error );
// Cleanup loaded shader
glDeleteShader( vshader );
glDeleteShader( tcshader );
glDeleteShader( teshader );
glDeleteShader( gshader );
glDeleteShader( fshader );
glDeleteShader( cshader );
sp->initialized = true;
// Bind the uniform buffer block slots
for( auto it = uniSlots.begin(); it != uniSlots.end(); ++it )
{
int loc = glGetUniformBlockIndex( sp->programID, it->first.c_str() );
CHECK_GL_ERROR();
if( loc >= 0 )
{
glUniformBlockBinding( sp->programID, loc, it->second );
CHECK_GL_ERROR();
// Build our list of actually existing uni buffers, so we don't bind something not allowed later
sp->bindSlots.emplace(std::pair<std::string, uint32_t>(it->first, it->second));
}
}
// Register with scene
AppManager::GetScene()->RegisterShader( programName, sp );
CHECK_GL_ERROR();
return sp;
}
GLuint loadShaders(const std::string & vertexFilePath,
const std::string & fragmentFilePath)
{
// Create the shaders
GLuint vertexShaderID = glCreateShader(GL_VERTEX_SHADER);
GLuint fragmentShaderID = glCreateShader(GL_FRAGMENT_SHADER);
// Read the Vertex Shader code from the file
std::ifstream vertexShaderStream(vertexFilePath);
if(!vertexShaderStream.is_open()) {
std::cerr << "Impossible to open " << vertexFilePath << '\n';
return 0;
}//if
std::string vertexShaderCode(
(std::istreambuf_iterator<char>(vertexShaderStream)),
std::istreambuf_iterator<char>());
// Read the Fragment Shader code from the file
std::ifstream fragmentShaderStream(fragmentFilePath);
if(!fragmentShaderStream.is_open()) {
std::cerr << "Impossible to open " << fragmentFilePath << '\n';
return 0;
}//if
std::string fragmentShaderCode(
(std::istreambuf_iterator<char>(fragmentShaderStream)),
std::istreambuf_iterator<char>());
GLint status = GL_FALSE;
int infoLogLength;
// Compile Vertex Shader
std::cout << "Compiling Vertex Shader: " << vertexFilePath << '\n';
const char * vertexSourcePointer = vertexShaderCode.c_str();
glShaderSource(vertexShaderID, 1, &vertexSourcePointer , nullptr);
glCompileShader(vertexShaderID);
// Check Vertex Shader
glGetShaderiv(vertexShaderID, GL_COMPILE_STATUS, &status);
glGetShaderiv(vertexShaderID, GL_INFO_LOG_LENGTH, &infoLogLength);
if(infoLogLength > 0){
std::string vertexShaderErrorMessage(infoLogLength + 1, '\0');
glGetShaderInfoLog(vertexShaderID, infoLogLength, nullptr,
(GLchar *)(vertexShaderErrorMessage.data()));
std::cerr << vertexShaderErrorMessage << '\n';
}//if
// Compile Fragment Shader
std::cout << "Compiling Fragment Shader: " << fragmentFilePath << '\n';
char const * fragmentSourcePointer = fragmentShaderCode.c_str();
glShaderSource(fragmentShaderID, 1, &fragmentSourcePointer, nullptr);
glCompileShader(fragmentShaderID);
// Check Fragment Shader
glGetShaderiv(fragmentShaderID, GL_COMPILE_STATUS, &status);
glGetShaderiv(fragmentShaderID, GL_INFO_LOG_LENGTH, &infoLogLength);
if(infoLogLength > 0){
std::string fragmentShaderErrorMessage(infoLogLength + 1, '\0');
glGetShaderInfoLog(fragmentShaderID, infoLogLength, nullptr,
(GLchar *)(fragmentShaderErrorMessage.data()));
std::cerr << fragmentShaderErrorMessage << '\n';
}//if
// Link the program
std::cout << "Linking program: " << vertexFilePath << " & "
<< fragmentFilePath << '\n';
GLuint programID = glCreateProgram();
glAttachShader(programID, vertexShaderID);
glAttachShader(programID, fragmentShaderID);
glLinkProgram(programID);
// Check the program
glGetProgramiv(programID, GL_LINK_STATUS, &status);
glGetProgramiv(programID, GL_INFO_LOG_LENGTH, &infoLogLength);
if(infoLogLength > 0){
std::string programErrorMessage(infoLogLength + 1, '\0');
glGetProgramInfoLog(programID, infoLogLength, nullptr,
(GLchar *)(programErrorMessage.data()));
std::cerr << programErrorMessage << '\n';
}//if
glDeleteShader(vertexShaderID);
glDeleteShader(fragmentShaderID);
return programID;
}//loadShaders(vertexShaderStream, fragmentFilePath)
GLuint initProgram(string vertexFile, string fragmentFile)
{
// Create shaders
GLuint vertexShaderID = glCreateShader(GL_VERTEX_SHADER);
GLuint fragmentShaderID = glCreateShader(GL_FRAGMENT_SHADER);
string tempV = getAeonDir()+vertexFile;
string tempF = getAeonDir()+fragmentFile;
string vertexCode;
string fragmentCode;
// Read vertex shader from file
ifstream vertexShaderStream(tempV.c_str(), std::ios::in);
if(vertexShaderStream.is_open())
{
string vLine = "";
while(getline(vertexShaderStream, vLine))
vertexCode += "\n" + vLine;
vertexShaderStream.close();
}
else
{
log("Failed to open vertex shader at: \""+tempV+"\"", AEON_ERROR);
return 0;
}
// Read fragment shader from file
ifstream fragmentShaderStream(tempF.c_str(), std::ios::in);
if(fragmentShaderStream.is_open())
{
string fLine = "";
while(getline(fragmentShaderStream, fLine))
fragmentCode += "\n" + fLine;
fragmentShaderStream.close();
}
else
{
log("Failed to open fragment shader at: \""+tempF+"\"", AEON_ERROR);
return 0;
}
GLint result = GL_FALSE;
int infoLogLength;
// Compile Vertex Shader
log("Compiling vertex shader: \""+vertexFile+"\"", AEON_INFO);
char const * vertexSourcePointer = vertexCode.c_str();
glShaderSource(vertexShaderID, 1, &vertexSourcePointer, NULL);
glCompileShader(vertexShaderID);
// Check Vertex Shader
glGetShaderiv(vertexShaderID, GL_COMPILE_STATUS, &result);
glGetShaderiv(vertexShaderID, GL_INFO_LOG_LENGTH, &infoLogLength);
if ( infoLogLength > 0 )
{
std::vector<char> vertexShaderErrorMessage(infoLogLength+1);
glGetShaderInfoLog(vertexShaderID, infoLogLength, NULL, &vertexShaderErrorMessage[0]);
if(vertexShaderErrorMessage.size() > 2)
log(vertexShaderErrorMessage, AEON_ERROR);
}
// Compile Fragment Shader
log("Compiling fragment shader: \""+fragmentFile+"\"", AEON_INFO);
char const * fragmentSourcePointer = fragmentCode.c_str();
glShaderSource(fragmentShaderID, 1, &fragmentSourcePointer, NULL);
glCompileShader(fragmentShaderID);
// Check Vertex Shader
glGetShaderiv(fragmentShaderID, GL_COMPILE_STATUS, &result);
glGetShaderiv(fragmentShaderID, GL_INFO_LOG_LENGTH, &infoLogLength);
if ( infoLogLength > 0 )
{
std::vector<char> fragmentShaderErrorMessage(infoLogLength+1);
glGetShaderInfoLog(fragmentShaderID, infoLogLength, NULL, &fragmentShaderErrorMessage[0]);
if(fragmentShaderErrorMessage.size() > 2)
log(fragmentShaderErrorMessage, AEON_ERROR);
}
// Link program
log("Linking program.", AEON_INFO);
GLuint programID = glCreateProgram();
glAttachShader(programID, vertexShaderID);
glAttachShader(programID, fragmentShaderID);
glLinkProgram(programID);
// Check the program
glGetProgramiv(programID, GL_LINK_STATUS, &result);
glGetProgramiv(programID, GL_INFO_LOG_LENGTH, &infoLogLength);
if ( infoLogLength > 0 )
{
std::vector<char> programErrorMessage(infoLogLength+1);
glGetProgramInfoLog(programID, infoLogLength, NULL, &programErrorMessage[0]);
if(programErrorMessage.size() > 2)
log(programErrorMessage, AEON_ERROR);
}
// Clean up
glDeleteShader(vertexShaderID);
glDeleteShader(fragmentShaderID);
return programID;
}
int Mesh::loadShaders(const char* vertexFile, const char* fragmentFile)
{
GLint result = GL_FALSE;
int infoLogLength;
GLuint vertexShaderID = glCreateShader(GL_VERTEX_SHADER);
GLuint fragmentShaderID = glCreateShader(GL_FRAGMENT_SHADER);
std::ofstream outputLog("output.txt", std::ios::out);
std::string vertexShaderCode;
std::ifstream vertexShaderStream(vertexFile, std::ios::in);
if(vertexShaderStream.is_open())
{
char line[256];
while(vertexShaderStream.getline(line, 256))
{
vertexShaderCode += std::string("\n");
vertexShaderCode += std::string(line);
}
vertexShaderStream.close();
}
const char* vertexShaderSource = vertexShaderCode.c_str();
// Compile vertex shader
glShaderSource(vertexShaderID, 1, &vertexShaderSource, NULL);
glCompileShader(vertexShaderID);
// Check vertex shader
glGetShaderiv(vertexShaderID, GL_COMPILE_STATUS, &result);
glGetShaderiv(vertexShaderID, GL_INFO_LOG_LENGTH, &infoLogLength);
std::vector<char> vertexShaderErrorMessage(infoLogLength);
glGetShaderInfoLog(vertexShaderID, infoLogLength, NULL, &vertexShaderErrorMessage[0]);
if(outputLog.is_open())
{
outputLog<<&vertexShaderErrorMessage[0]<<std::endl;
}
std::string fragmentShaderCode;
std::ifstream fragmentShaderStream(fragmentFile, std::ios::in);
if(fragmentShaderStream.is_open())
{
char line[256];
while(fragmentShaderStream.getline(line, 256))
{
fragmentShaderCode += std::string("\n");
fragmentShaderCode += std::string(line);
}
fragmentShaderStream.close();
}
const char* fragmentShaderSource = fragmentShaderCode.c_str();
// Compile fragment shader
glShaderSource(fragmentShaderID, 1, &fragmentShaderSource, NULL);
glCompileShader(fragmentShaderID);
// Check fragment shader
glGetShaderiv(fragmentShaderID, GL_COMPILE_STATUS, &result);
glGetShaderiv(fragmentShaderID, GL_INFO_LOG_LENGTH, &infoLogLength);
std::vector<char> fragmentShaderErrorMessage(infoLogLength);
glGetShaderInfoLog(fragmentShaderID, infoLogLength, NULL, &fragmentShaderErrorMessage[0]);
if(outputLog.is_open())
{
outputLog<<&fragmentShaderErrorMessage[0]<<std::endl;
}
// Create and link a program
GLuint programID = glCreateProgram();
glAttachShader(programID, vertexShaderID);
glAttachShader(programID, fragmentShaderID);
glLinkProgram(programID);
// Check the program
glGetProgramiv(programID, GL_LINK_STATUS, &result);
glGetProgramiv(programID, GL_INFO_LOG_LENGTH, &infoLogLength);
std::vector<char> programErrorMessage(infoLogLength);
glGetProgramInfoLog(programID, infoLogLength, NULL, &programErrorMessage[0]);
if(outputLog.is_open())
{
outputLog<<&programErrorMessage[0]<<std::endl;
}
outputLog.close();
glDeleteShader(vertexShaderID);
glDeleteShader(fragmentShaderID);
return programID;
}
GLboolean Program::loadShaders(std::string vertex_file_path, std::string fragment_file_path)
{
GLuint vertexShaderId = glCreateShader(GL_VERTEX_SHADER);
GLuint fragmentShaderId = glCreateShader(GL_FRAGMENT_SHADER);
std::string vertexShaderCode;
std::ifstream vertexShaderStream(vertex_file_path, std::ios::in);
if(vertexShaderStream.is_open())
{
std::string line = "";
while(getline(vertexShaderStream, line))
vertexShaderCode += "\n" + line;
vertexShaderStream.close();
}
else
{
std::cerr << clog::err << "Cannot open " << vertex_file_path << "." << std::endl;
std::cin.get();
return GL_FALSE;
}
std::string fragmentShaderCode;
std::ifstream fragmentShaderStream(fragment_file_path, std::ios::in);
if(fragmentShaderStream.is_open())
{
std::string line = "";
while(getline(fragmentShaderStream, line))
fragmentShaderCode += "\n" + line;
fragmentShaderStream.close();
}
GLint result = GL_FALSE;
GLint infoLogLength;
//compile vertex shader
std::cout << clog::inf << "Compiling shader (" << vertex_file_path << ")..." << std::endl;
char const* vertexSourcePointer = vertexShaderCode.c_str();
glShaderSource(vertexShaderId, 1, &vertexSourcePointer , NULL);
glCompileShader(vertexShaderId);
//check vertex shader
glGetShaderiv(vertexShaderId, GL_COMPILE_STATUS, &result);
glGetShaderiv(vertexShaderId, GL_INFO_LOG_LENGTH, &infoLogLength);
if(infoLogLength > 0)
{
std::vector<char> vertexShaderErrorMessage(infoLogLength + 1);
glGetShaderInfoLog(vertexShaderId, infoLogLength, NULL, &vertexShaderErrorMessage[0]);
std::cerr << clog::err << &vertexShaderErrorMessage[0] << std::endl;
}
//compile fragment shader
std::cout << clog::inf << "Compiling shader (" << fragment_file_path << ")..." << std::endl;
char const* fragmentSourcePointer = fragmentShaderCode.c_str();
glShaderSource(fragmentShaderId, 1, &fragmentSourcePointer , NULL);
glCompileShader(fragmentShaderId);
//check fragment shader
glGetShaderiv(fragmentShaderId, GL_COMPILE_STATUS, &result);
glGetShaderiv(fragmentShaderId, GL_INFO_LOG_LENGTH, &infoLogLength);
if(infoLogLength > 0)
{
std::vector<char> fragmentShaderErrorMessage(infoLogLength + 1);
glGetShaderInfoLog(fragmentShaderId, infoLogLength, NULL, &fragmentShaderErrorMessage[0]);
std::cerr << clog::err << &fragmentShaderErrorMessage[0] << std::endl;
}
//link the program
std::cout << clog::inf << "Linking program..." << std::endl;
instance = glCreateProgram();
glAttachShader(instance, vertexShaderId);
glAttachShader(instance, fragmentShaderId);
glLinkProgram(instance);
//check the program
glGetProgramiv(instance, GL_LINK_STATUS, &result);
glGetProgramiv(instance, GL_INFO_LOG_LENGTH, &infoLogLength);
if(infoLogLength > 0)
{
std::vector<char> programErrorMessage(infoLogLength + 1);
glGetProgramInfoLog(instance, infoLogLength, NULL, &programErrorMessage[0]);
std::cerr << clog::err << &programErrorMessage[0] << std::endl;
}
glDeleteShader(vertexShaderId);
glDeleteShader(fragmentShaderId);
return GL_TRUE;
}
