RTVolumeRendering/Source/Shader.cpp

Go to the documentation of this file.

#include <fstream>
#include <string>
#include "Error.h"
#include "Shader.h"

/*
 * \brief Loads and compiles a GLSL shader from a string in memory. 
 *
 * \param[in] type the shader type. GL_FRAGMENT_SHADER or GL_VERTEX_SHADER.
 * \param[in] src string holding the shader source
 * \param[out] shader the created shader id.
 *
 * \return true if the shader was loaded and compiled successfully, false otherwise.
 */
bool LoadShaderFromMemory(GLenum type, const char *src, GLuint &shader)
{
        if(!src)
                return false;

        shader = glCreateShader(type);
        
        glShaderSource(shader, 1, &src, NULL);
        glCompileShader(shader);
        
        GLint err;
        glGetShaderiv(shader, GL_COMPILE_STATUS, &err);
        if(err == GL_FALSE)
        {
                // Gets and reports the error log.
                GLint maxLogLen;
                glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &maxLogLen);
                
                char *log = new char[maxLogLen];
                GLsizei logLen;
                glGetShaderInfoLog(shader, maxLogLen, &logLen, log);
                
                std::string title = "ERROR";
                ErrorMessage(title.c_str(), log);
                
                delete log;
                return false;
        }
        
        return true;
}

/*
 * \brief Loads and compiles a GLSL shader. 
 *
 * \param[in] type the shader type. GL_FRAGMENT_SHADER or GL_VERTEX_SHADER.
 * \param[in] file the shader source file.
 * \param[out] shader the created shader id.
 *
 * \return true if the shader was loaded and compiled successfully, false otherwise.
 */
bool LoadShader(GLenum type, const char *file, GLuint &shader)
{
        std::fstream f(file);
        
        if(!f.is_open())
        {
                std::string msg = "Could Not open shader source file : ";
                msg += file;
                ErrorMessage(msg.c_str());
                return false;
        }
        
        std::string source = "";
        std::string line = "";
        
        while(getline(f, line))
        {
                source += line;
        }

        return LoadShaderFromMemory(type, source.c_str(), shader);
        
        
}

//----------------------------------------------------------
PixelShader::PixelShader() : shader(0) {}

//----------------------------------------------------------
PixelShader::~PixelShader() 
{
        if(shader)
                glDeleteShader(shader);
}

//----------------------------------------------------------
bool PixelShader::Load(const char *file)
{
        return LoadShader(GL_FRAGMENT_SHADER, file, shader);
}

//----------------------------------------------------------
bool PixelShader::LoadFromMemory(const char *src)
{
        return LoadShaderFromMemory(GL_FRAGMENT_SHADER, src, shader);
}

//----------------------------------------------------------
VertexShader::VertexShader() : shader(0) {}
                
//----------------------------------------------------------
VertexShader::~VertexShader()
{
        if(shader)
                glDeleteShader(shader);
}
                
//----------------------------------------------------------
bool VertexShader::Load(const char *file)
{
        return LoadShader(GL_VERTEX_SHADER, file, shader);
}

//----------------------------------------------------------
bool VertexShader::LoadFromMemory(const char *src)
{
        return LoadShaderFromMemory(GL_VERTEX_SHADER, src, shader);
}

//----------------------------------------------------------
ShaderProgram::ShaderProgram() : program(0) {}
                
//----------------------------------------------------------
ShaderProgram::~ShaderProgram()
{
        if(program)
        {
                if(vshader.GetShaderID())
                        glDetachShader(program, vshader.GetShaderID());
                
                if(pshader.GetShaderID())
                        glDetachShader(program, pshader.GetShaderID());
                
                glDeleteProgram(program);
        }
}
                
//----------------------------------------------------------
bool ShaderProgram::Load(const char *vertexFile, const char *pixelFile)
{
        if(!vertexFile && !pixelFile)
                return false;
        
        if(vertexFile)
        {
                if(!vshader.Load(vertexFile))
                        return false;
        }
        
        if(pixelFile)
        {
                if(!pshader.Load(pixelFile))
                        return false;
        }
        
        return CreateShaderProgram();
}

//----------------------------------------------------------
bool ShaderProgram::LoadFromMemory(const char *vertexSrc, const char *pixelSrc)
{
        if(!vertexSrc && !pixelSrc)
                return false;
        
        if(vertexSrc)
        {
                if(!vshader.LoadFromMemory(vertexSrc))
                        return false;
        }
        
        if(pixelSrc)
        {
                if(!pshader.LoadFromMemory(pixelSrc))
                        return false;
        }
        
        return CreateShaderProgram();
}


//----------------------------------------------------------
bool ShaderProgram::CreateShaderProgram()
{
        program = glCreateProgram();
        
        if(vshader.GetShaderID())
                glAttachShader(program, vshader.GetShaderID());
        
        if(pshader.GetShaderID())
                glAttachShader(program, pshader.GetShaderID());
        
        glLinkProgram(program);
        
        GLint err;
        glGetProgramiv(program, GL_LINK_STATUS, &err);
        if(err == GL_FALSE)
        {
                // Gets and reports the error log.
                GLint maxLogLen;
                glGetProgramiv(program, GL_INFO_LOG_LENGTH, &maxLogLen);
                
                char *log = new char[maxLogLen];
                GLsizei logLen;
                glGetProgramInfoLog(program, maxLogLen, &logLen, log);
                
                std::string title = "ERROR";
                ErrorMessage(title.c_str(), log);
                
                delete log;
                return false;
        }
        
        return true;
}
                
//----------------------------------------------------------
void ShaderProgram::Attach()
{
        glUseProgram(program);
}
                
//----------------------------------------------------------
void ShaderProgram::Detach()
{
        glUseProgram(0);
}

//----------------------------------------------------------
void ShaderProgram::SetTexture(GLuint texID, const char *name)
{
        glUseProgram(program);
        
        GLint loc = glGetUniformLocation(program, name);
        if(loc > -1)
        {
                glUniform1i(loc, texID);
        }
        
        glUseProgram(0);
}

//----------------------------------------------------------
void ShaderProgram::SetVector(float x, float y, float z, const char *name)
{
        glUseProgram(program);
        
        GLint loc = glGetUniformLocation(program, name);
        if(loc > -1)
        {
                glUniform3f(loc, x, y, z);
        }
        
        glUseProgram(0);
}

//----------------------------------------------------------
void ShaderProgram::SetFloat(float val, const char *name)
{
        glUseProgram(program);
        
        GLint loc = glGetUniformLocation(program, name);
        if(loc > -1)
        {
                glUniform1f(loc, val);
        }
        
        glUseProgram(0);
}

---