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