void Shader::checkShaderError()
{
GLint Result = GL_FALSE;
int infoLogLen;
glGetShaderiv(_vertexShaderID, GL_COMPILE_STATUS, &Result);
glGetShaderiv(_vertexShaderID, GL_INFO_LOG_LENGTH, &infoLogLen);
std::vector<char> vertexShaderErrorMessage(infoLogLen);
glGetShaderInfoLog(_vertexShaderID, infoLogLen, NULL, &vertexShaderErrorMessage[0]);
std::string errorMsg(vertexShaderErrorMessage.begin(), vertexShaderErrorMessage.end());
#ifdef _DEBUG
std::cout << errorMsg << std::endl;
#endif
glGetShaderiv(_fragmentShaderID, GL_COMPILE_STATUS, &Result);
glGetShaderiv(_fragmentShaderID, GL_INFO_LOG_LENGTH, &infoLogLen);
std::vector<char> fragmentShaderErrorMessage(infoLogLen);
glGetShaderInfoLog(_fragmentShaderID, infoLogLen, NULL, &fragmentShaderErrorMessage[0]);
errorMsg.clear();
errorMsg = std::string(fragmentShaderErrorMessage.begin(), fragmentShaderErrorMessage.end());
#ifdef _DEBUG
std::cout << errorMsg << std::endl;
#endif
}
int ProgramGLSL::insertFragmentShader(std::string _fsPath)
{
if(_fsPath == "")
return -1;
//TODO: Check if fragment shader is already compiled
//create fragment shader
GLuint fs = glCreateShader(GL_FRAGMENT_SHADER);
//read fragment shader code from file
std::string fragmentShaderCode;
std::ifstream fragmentShaderStream(_fsPath, std::ios::in);
if(fragmentShaderStream.is_open())
{
std::string line = "";
while(getline(fragmentShaderStream, line))
fragmentShaderCode += "\n" + line;
fragmentShaderStream.close();
}
else
{
printf("file %s not found\n", _fsPath.c_str());
}
GLint result = GL_FALSE;
int infoLogLength;
//Compile fragment shader
printf("Compiling fragment shader: %s\n", _fsPath.c_str());
const char *fragmentSourcePtr = fragmentShaderCode.c_str();
glShaderSource(fs, 1, &fragmentSourcePtr, NULL);
glCompileShader(fs);
//check fragment shader
glGetShaderiv(fs, GL_COMPILE_STATUS, &result);
glGetShaderiv(fs, GL_INFO_LOG_LENGTH, &infoLogLength);
std::vector<char> fragmentShaderErrorMessage(infoLogLength);
fprintf(stdout, "%Shader Message: s\n", &fragmentShaderErrorMessage[0]);
//return something else if failed? or maybe throw exeption... we'll see
if(result == GL_TRUE)
{
FSstruct f;
f.name = _fsPath;
f.fragmentShader = fs;
fragmentShaders->push_back(f);
printf("successfully compiled fragment shader: %s\n\n", _fsPath.c_str());
return (int)fs;
}
else
{
printf("failed to compile fragment shader %s\n\n", _fsPath.c_str());
}
return -1;
}
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;
}
