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; }