void Shader::Compile(const GLchar* vertexSource, const GLchar* fragmentSource, const GLchar* geometrySource) { GLuint sVertex, sFragment, gShader; // Vertex Shader sVertex = glCreateShader(GL_VERTEX_SHADER); glShaderSource(sVertex, 1, &vertexSource, NULL); glCompileShader(sVertex); checkCompileErrors(sVertex, "VERTEX"); // Fragment Shader sFragment = glCreateShader(GL_FRAGMENT_SHADER); glShaderSource(sFragment, 1, &fragmentSource, NULL); glCompileShader(sFragment); checkCompileErrors(sFragment, "FRAGMENT"); // If geometry shader source code is given, also compile geometry shader if (geometrySource != nullptr) { gShader = glCreateShader(GL_GEOMETRY_SHADER); glShaderSource(gShader, 1, &geometrySource, NULL); glCompileShader(gShader); checkCompileErrors(gShader, "GEOMETRY"); } // Shader Program this->ID = glCreateProgram(); glAttachShader(this->ID, sVertex); glAttachShader(this->ID, sFragment); if (geometrySource != nullptr) glAttachShader(this->ID, gShader); glLinkProgram(this->ID); checkCompileErrors(this->ID, "PROGRAM"); // Delete the shaders as they're linked into our program now and no longer necessery glDeleteShader(sVertex); glDeleteShader(sFragment); if (geometrySource != nullptr) glDeleteShader(gShader); }
void Shader::compile( const GLchar *vertexSource, const GLchar *fragmentSource, const GLchar *geometrySource ) { GLuint sVertex, sFragment, sGeometry; // vertex shader sVertex = glCreateShader( GL_VERTEX_SHADER ); glShaderSource( sVertex, 1, &vertexSource, NULL ); glCompileShader( sVertex ); checkCompileErrors( sVertex, "VERTEX" ); // fragment shader sFragment = glCreateShader( GL_FRAGMENT_SHADER ); glShaderSource( sFragment, 1, &fragmentSource, NULL ); glCompileShader( sFragment ); checkCompileErrors( sFragment, "FRAGMENT" ); // geometry shader if source code is given if ( geometrySource != nullptr ) { sGeometry = glCreateShader( GL_GEOMETRY_SHADER ); glShaderSource( sGeometry, 1, &geometrySource, NULL ); glCompileShader( sGeometry ); checkCompileErrors( sGeometry, "GEOMETRY" ); } // create the shader program ID = glCreateProgram(); glAttachShader( ID, sVertex ); glAttachShader( ID, sFragment ); if ( geometrySource != nullptr ) { glAttachShader( ID, sGeometry ); } glLinkProgram( ID ); checkCompileErrors( ID, "PROGRAM" ); // delete shaders glDeleteShader( sVertex ); glDeleteShader( sFragment ); if ( geometrySource != nullptr ) { glDeleteShader( sGeometry ); } }
void Shader::Compile(const GLchar* vertexSource, const GLchar* fragmentSource) { GLuint sVertex, sFragment; // Vertex Shader sVertex = glCreateShader(GL_VERTEX_SHADER); glShaderSource(sVertex, 1, &vertexSource, NULL); glCompileShader(sVertex); checkCompileErrors(sVertex, "VERTEX"); // Fragment Shader sFragment = glCreateShader(GL_FRAGMENT_SHADER); glShaderSource(sFragment, 1, &fragmentSource, NULL); glCompileShader(sFragment); checkCompileErrors(sFragment, "FRAGMENT"); // Shader Program this->ID = glCreateProgram(); glAttachShader(this->ID, sVertex); glAttachShader(this->ID, sFragment); glLinkProgram(this->ID); checkCompileErrors(this->ID, "PROGRAM"); // Delete the shaders as they're linked into our program now and no longer necessery glDeleteShader(sVertex); glDeleteShader(sFragment); }
void Shader::compileShader(GLuint *shader, GLenum type, const char *source, std::string shaderType) { *shader = glCreateShader(type); glShaderSource(*shader, 1, &source, NULL); glCompileShader(*shader); checkCompileErrors(shader, shaderType); }
Shader::Shader( const char* p_vertexPath, const char* p_fragmentPath, const char* p_geometryPath ) { // Read the vertex and fragment shader code from the file std::string vertexCode; std::string fragmentCode; std::string geometryCode; std::ifstream vShaderFile; std::ifstream fShaderFile; std::ifstream gShaderFile; // Open files vShaderFile.open( p_vertexPath ); fShaderFile.open( p_fragmentPath ); std::stringstream vShaderStream, fShaderStream; // Is the file opened if ( vShaderFile.is_open( ) ) { // Read file's buffer contents into streams vShaderStream << vShaderFile.rdbuf( ); // close file handlers vShaderFile.close( ); // Convert stream into string vertexCode = vShaderStream.str( ); } else { wxLogMessage( wxT( "Shader FILE_NOT_SUCCESFULLY_READ: %s" ), p_vertexPath ); throw exception::Exception( "Unable to read vertex shader file." ); } // Is the file opened if ( fShaderFile.is_open( ) ) { // Read file's buffer contents into streams fShaderStream << fShaderFile.rdbuf( ); // close file handlers fShaderFile.close( ); // Convert stream into string fragmentCode = fShaderStream.str( ); } else { wxLogMessage( wxT( "Shader FILE_NOT_SUCCESFULLY_READ: %s" ), p_fragmentPath ); throw exception::Exception( "Unable to read fragment shader file." ); } // If geometry shader path is present, also load a geometry shader if ( p_geometryPath != nullptr ) { // Open file gShaderFile.open( p_geometryPath ); // Is the file opened if ( gShaderFile.is_open( ) ) { std::stringstream gShaderStream; // Read file's buffer contents into streams gShaderStream << gShaderFile.rdbuf( ); // close file handlers gShaderFile.close( ); // Convert stream into string geometryCode = gShaderStream.str( ); } else { wxLogMessage( wxT( "Shader FILE_NOT_SUCCESFULLY_READ: %s" ), p_geometryPath ); throw exception::Exception( "Unable to read geometry shader file." ); } } // Compile Vertex Shader wxLogMessage( wxT( "Compiling vertex shader : %s" ), p_vertexPath ); GLuint vertex = glCreateShader( GL_VERTEX_SHADER ); const GLchar *vShaderCode = vertexCode.c_str( ); glShaderSource( vertex, 1, &vShaderCode, NULL ); glCompileShader( vertex ); if ( !checkCompileErrors( vertex, "VERTEX" ) ) { glDeleteShader( vertex ); throw exception::Exception( "Vertex shader compilation error." ); } // Compile Fragment Shader wxLogMessage( wxT( "Compiling fragment shader : %s" ), p_fragmentPath ); GLuint fragment = glCreateShader( GL_FRAGMENT_SHADER ); const GLchar *fShaderCode = fragmentCode.c_str( ); glShaderSource( fragment, 1, &fShaderCode, NULL ); glCompileShader( fragment ); if ( !checkCompileErrors( fragment, "FRAGMENT" ) ) { glDeleteShader( vertex ); glDeleteShader( fragment ); throw exception::Exception( "Fragment shader compilation error." ); } // If geometry shader is given, compile geometry shader GLuint geometry = 0; if ( p_geometryPath != nullptr ) { wxLogMessage( wxT( "Compiling geometry shader : %s" ), p_geometryPath ); const GLchar * gShaderCode = geometryCode.c_str( ); geometry = glCreateShader( GL_GEOMETRY_SHADER ); glShaderSource( geometry, 1, &gShaderCode, NULL ); glCompileShader( geometry ); if ( !checkCompileErrors( geometry, "GEOMETRY" ) ) { glDeleteShader( vertex ); glDeleteShader( fragment ); glDeleteShader( geometry ); throw exception::Exception( "Geometry shader compilation error." ); } } // Shader Program wxLogMessage( wxT( "Linking shader program..." ) ); m_program = glCreateProgram( ); glAttachShader( m_program, vertex ); glAttachShader( m_program, fragment ); if ( p_geometryPath != nullptr ) { glAttachShader( m_program, geometry ); } glLinkProgram( m_program ); if ( checkCompileErrors( m_program, "PROGRAM" ) ) { wxLogMessage( wxT( "Done linking shader program." ) ); } // Delete the shaders as they're linked into our program now and no longer necessery glDeleteShader( vertex ); glDeleteShader( fragment ); if ( p_geometryPath != nullptr ) { glDeleteShader( geometry ); } }
Shader::Shader(const GLchar* vertexPath, const GLchar* fragmentPath, const GLchar* geometryPath) { // 1. Retrieve the vertex/fragment source code from filePath std::string vertexCode; std::string fragmentCode; std::string geometryCode; std::ifstream vShaderFile; std::ifstream fShaderFile; std::ifstream gShaderFile; // ensures ifstream objects can throw exceptions: vShaderFile.exceptions (std::ifstream::failbit | std::ifstream::badbit); fShaderFile.exceptions (std::ifstream::failbit | std::ifstream::badbit); gShaderFile.exceptions (std::ifstream::failbit | std::ifstream::badbit); try { // open file vShaderFile.open(vertexPath); fShaderFile.open(fragmentPath); std::stringstream vShaderStream, fShaderStream; // Read file's buffer contents into streams vShaderStream << vShaderFile.rdbuf(); fShaderStream << fShaderFile.rdbuf(); // close file handlers vShaderFile.close(); fShaderFile.close(); // Convert stream into string vertexCode = vShaderStream.str(); fragmentCode = fShaderStream.str(); // If geometry shader path is present, also load a geometry shader if (geometryPath != nullptr) { gShaderFile.open(geometryPath); std::stringstream gShaderStream; gShaderStream << gShaderFile.rdbuf(); gShaderFile.close(); geometryCode = gShaderStream.str(); } } catch (std::ifstream::failure e) { std::cout << "ERROR::SHADER::FILE_NOT_SUCCESFULLY_READ"<<strerror(errno) << std::endl; } const GLchar* vShaderCode = vertexCode.c_str(); const GLchar* fShaderCode = fragmentCode.c_str(); // 2. compile shaders. GLuint vertex, fragment; GLint success; GLchar infoLog[512]; // Vertex shader vertex = glCreateShader(GL_VERTEX_SHADER); glShaderSource(vertex, 1, &vShaderCode, NULL); glCompileShader(vertex); checkCompileErrors(vertex, "VERTEX"); // Fragment Shader fragment = glCreateShader(GL_FRAGMENT_SHADER); glShaderSource(fragment, 1, &fShaderCode, NULL); glCompileShader(fragment); checkCompileErrors(fragment, "FRAGMENT"); // If geometry shader is given, compile geometry shader GLuint geometry; if(geometryPath != nullptr) { const GLchar * gShaderCode = geometryCode.c_str(); geometry = glCreateShader(GL_GEOMETRY_SHADER); glShaderSource(geometry, 1, &gShaderCode, NULL); glCompileShader(geometry); checkCompileErrors(geometry, "GEOMETRY"); } // shader program mProgram = glCreateProgram(); glAttachShader(mProgram, vertex); glAttachShader(mProgram, fragment); if (geometryPath != nullptr) { glAttachShader(mProgram, geometry); } glLinkProgram(mProgram); checkCompileErrors(mProgram, "PROGRAM"); // Delete the shaders as they're linked into our program now and no longer necessery glDeleteShader(vertex); glDeleteShader(fragment); if (geometryPath != nullptr) { glDeleteShader(geometry); } }
bool Shader::addShader(const std::string& shader, UI32 type) { const char* shaderSrc = shader.c_str(); bool success = false; UI32 shaderHandle = 0; switch (type) { case ODIN_VERTEX_SHADER: shaderHandle = render::lib::createShader(ODIN_VERTEX_SHADER); render::lib::shaderSource(shaderHandle, 1, &shaderSrc, nullptr); render::lib::compileShader(shaderHandle); success = checkCompileErrors(shaderHandle, "VERTEX"); break; case ODIN_FRAGMENT_SHADER: shaderHandle = render::lib::createShader(ODIN_FRAGMENT_SHADER); render::lib::shaderSource(shaderHandle, 1, &shaderSrc, nullptr); render::lib::compileShader(shaderHandle); success = checkCompileErrors(shaderHandle, "FRAGMENT"); break; case ODIN_GEOMETRY_SHADER: shaderHandle = render::lib::createShader(ODIN_GEOMETRY_SHADER); render::lib::shaderSource(shaderHandle, 1, &shaderSrc, nullptr); render::lib::compileShader(shaderHandle); success = checkCompileErrors(shaderHandle, "GEOMETRY"); break; case ODIN_TESS_CONTROL_SHADER: shaderHandle =render::lib::createShader(ODIN_TESS_CONTROL_SHADER); render::lib::shaderSource(shaderHandle, 1, &shaderSrc, nullptr); render::lib::compileShader(shaderHandle); success = checkCompileErrors(shaderHandle, "TESSELATION_CONTROL"); break; case ODIN_TESS_EVALUATION_SHADER: shaderHandle = render::lib::createShader(ODIN_TESS_EVALUATION_SHADER); render::lib::shaderSource(shaderHandle, 1, &shaderSrc, nullptr); render::lib::compileShader(shaderHandle); success = checkCompileErrors(shaderHandle, "TESSELATION_EVALUATION"); break; #if defined ODIN_COMPUTE_SHADER case ODIN_COMPUTE_SHADER: shaderHandle = render::lib::createShader(ODIN_COMPUTE_SHADER); render::lib::shaderSource(shaderHandle, 1, &shaderSrc, nullptr); render::lib::compileShader(shaderHandle); success = checkCompileErrors(shaderHandle, "COMPUTE"); break; #endif default: LOG_ERROR("Unsupported shader type"); return false; } if (success) { render::lib::attachShader(m_program, shaderHandle); render::lib::deleteShader(shaderHandle); } else { render::lib::deleteShader(shaderHandle); render::lib::deleteProgram(m_program); m_program = 0; } return success; }