GLuint Shader::createShader( GLenum type, const char* pFileName )
{
GLint length;
char* pSource = (char*) fileContents( pFileName, &length );
GLuint shader;
GLint shaderOK;
if(!pSource)
{
return 0;
}
shader = glCreateShader( type );
glShaderSource( shader, 1, (const char**) &pSource, &length );
free( pSource );
glCompileShader( shader );
glGetShaderiv( shader, GL_COMPILE_STATUS, &shaderOK );
if(!shaderOK)
{
fprintf(stderr, "Failed to compile %s:\n", pFileName );
showInfoLog( shader, glGetShaderiv, glGetShaderInfoLog );
glDeleteShader( shader );
return 0;
}
// No errors return shader ID
return shader;
}
int GLResources::makeProgramBody(){
GLint program_ok;
glLinkProgram(programs.back());
glGetProgramiv(programs.back(), GL_LINK_STATUS, &program_ok);
if (!program_ok) {
std::cerr << "Failed to link shader program:\n";
showInfoLog(programs.back(), glGetProgramiv, glGetProgramInfoLog);
glDeleteProgram(programs.back());
programs.erase(programs.end());
return -1;
}
return programs.size()-1;
}
/**
* Loads a GLSL shader from disk, compiles it and returns it's assigned object
* id
*
* \param type The type of OpenGL shader to create
* \param filename Path to the shader code
* \return Shader's object id
*/
GLuint loadShader( GLenum type, const std::string& filename )
{
std::cout << "Loading shader: " << filename << std::endl;
// Load the shader source code from disk and verify that everything went
// according to plan
bool didWork = false;
std::string source = loadTextFile( filename, &didWork );
if (! didWork )
{
std::cerr << "Failed to load shader from disk: " << filename << std::endl;
exit( 1 );
}
// Generate a new shader object
GLuint shader = glCreateShader( type );
// Load the source code into the hardware, and then instruct OpenGL to
// compile it into machine bytecode.
//
// OpennGL really wants the shader to be an array of char*... not sure why
const char * pSource = source.c_str();
int sourceLength = static_cast<int>( source.size() );
glShaderSource( shader, 1, &pSource, &sourceLength );
glCompileShader( shader );
// Check to see if the shader successfully compiled. If it didn't, go figure
// out why
GLint ok = 0;
glGetShaderiv( shader, GL_COMPILE_STATUS, &ok );
if (! ok )
{
std::cerr << "Failed to compile: " << filename << std::endl;
std::string error = showInfoLog( shader, glGetShaderiv, glGetShaderInfoLog );
std::cerr << "ERROR: " << error << std::endl;
exit( 1 );
}
return shader;
}
GLuint Shader::createShaderProgram( GLuint vertexShader, GLuint pixelShader )
{
GLint programOK;
GLuint program = glCreateProgram();
glAttachShader( program, m_VertexShader );
glAttachShader( program, m_FragmentShader );
glLinkProgram( program );
glGetProgramiv( program, GL_LINK_STATUS, &programOK );
if(!programOK)
{
fprintf( stderr, "Failed to link shader program:\n" );
showInfoLog( program, glGetProgramiv, glGetProgramInfoLog );
glDeleteProgram( program );
return 0;
}
return program;
}
/**
* Creates a new shader object by loading the requested vertex shader and
* fragment shader. The engine will load both of these from disk, compile them
* and then assemble the final shader program.
*
* \param vertexShader Path to the vertex shader
* \param fragmentShader Path to the fragment shader
* \return Shader object containing details on the shader
*/
Shader loadShaderProgram( const std::string& vertexShader,
const std::string& fragmentShader )
{
Shader shader;
// First attempt to load and compile the requested vertex and fragment
// shaders
shader.vertexShader = loadShader( GL_VERTEX_SHADER, vertexShader );
shader.fragmentShader = loadShader( GL_FRAGMENT_SHADER, fragmentShader );
// Generate a new shader program
shader.program = glCreateProgram();
// Attach the vertex and fragment shaders
glAttachShader( shader.program, shader.vertexShader );
glAttachShader( shader.program, shader.fragmentShader );
glLinkProgram( shader.program );
errorCheck( "Linking shader" );
// Check if we were able to succesfully create the shader program
GLint ok = 0;
glGetProgramiv( shader.program, GL_LINK_STATUS, &ok );
if (! ok )
{
std::string message =
showInfoLog( shader.program, glGetProgramiv, glGetProgramInfoLog );
std::cerr << "Failed to link shader program" << std::endl;
std::cerr << "ERROR: " << message << std::endl;
exit( 1 );
}
return shader;
}
int GLResources::makeShader(GLenum type, const char *filename)
{
std::string source = fileContents(filename);
GLint length = source.size();
const GLchar* text = source.c_str();
GLuint shader;
GLint shader_ok;
if (source.size()== 0)
return 0;
shader = glCreateShader(type);
glShaderSource(shader, 1, &text, &length);
glCompileShader(shader);
glGetShaderiv(shader, GL_COMPILE_STATUS, &shader_ok);
if (!shader_ok) {
fprintf(stderr, "Failed to compile %s:\n", filename);
showInfoLog(shader, glGetShaderiv, glGetShaderInfoLog);
glDeleteShader(shader);
return 0;
}
shaders.push_back(shader);
return shaders.size();
}
