shader.hpp

Go to the documentation of this file.

#ifndef __TUCANOSHADER__
#define __TUCANOSHADER__

#include "utils/misc.hpp"

#include <fstream>
#include <vector>
#include <Eigen/Dense>
#include <memory>

using namespace std;

namespace Tucano
{

class Shader {

private:

    string shaderName;

    string vertexShaderPath;

    string tessellationControlShaderPath;

    string tessellationEvaluationShaderPath;

    string geometryShaderPath;

    string fragmentShaderPath;

    string computeShaderPath;

    string vertex_code;

    string fragment_code;

    string geometry_code;
    
    string tessellation_evaluation_code;
    
    string tessellation_control_code;

    string compute_shader_code;

    GLuint computeShader = 0;

    GLuint vertexShader = 0;

    GLuint tessellationControlShader = 0;

    GLuint tessellationEvaluationShader = 0;

    GLuint geometryShader = 0;

    GLuint fragmentShader = 0;

    GLuint shaderProgram = 0;

    int debug_level = 1;

    std::shared_ptr < GLuint > programID_sptr = 0;
    std::shared_ptr < GLuint > vertexID_sptr = 0;
    std::shared_ptr < GLuint > fragID_sptr = 0;
    std::shared_ptr < GLuint > geomID_sptr = 0;
    std::shared_ptr < GLuint > tessEvalID_sptr = 0;
    std::shared_ptr < GLuint > tessContID_sptr = 0;
    std::shared_ptr < GLuint > computeID_sptr = 0;

public:

    /*Shader (const Shader& other)
    {
        shaderName = other.shaderName;
        vertexShaderPath = other.vertexShaderPath;
        fragmentShaderPath = other.fragmentShaderPath;
        geometryShaderPath = other.geometryShaderPath;
        tessellationControlShaderPath = other.tessellationControlShaderPath;
        tessellationEvaluationShaderPath = other.tessellationEvaluationShaderPath;
        computeShaderPaths = other.computeShaderPaths;

        vertex_code = other.vertex_code;
        fragment_code = other.fragment_code;
        geometry_code = other.geometry_code;
        tessellation_evaluation_code = other.tessellation_evaluation_code;
        tessellation_control_code = other.tessellation_control_code;

        debug_level = other.debug_level;

        initializeFromStrings(vertex_code, fragment_code, geometry_code, tessellation_evaluation_code, tessellation_control_code);
        
        #ifdef TUCANODEBUG
        Misc::errorCheckFunc(__FILE__, __LINE__);
        #endif
    }*/
    
    void createProgramID (void)
    {

        shaderProgram = glCreateProgram();
        programID_sptr = std::shared_ptr < GLuint > ( 
                    new GLuint (shaderProgram),
                    [] (GLuint *p) {
                        glDeleteProgram(*p);
                        delete p;
                    }
                    );

    }

    void createShaders (void)
    {
     
        if (!(fragmentShaderPath.empty() && fragment_code.empty()) && fragID_sptr == 0)
        {   
            fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
            fragID_sptr = std::shared_ptr < GLuint > ( 
                        new GLuint (fragmentShader),
                        [] (GLuint *p) {
                            glDeleteShader(*p);
                            delete p;
                        }
                        );
        }

        if (!(vertexShaderPath.empty() && vertex_code.empty()) && vertexID_sptr == 0)
        {   
            vertexShader = glCreateShader(GL_VERTEX_SHADER);
            vertexID_sptr = std::shared_ptr < GLuint > ( 
                        new GLuint (vertexShader),
                        [] (GLuint *p) {
                            glDeleteShader(*p);
                            delete p;
                        }
                        );
        }

        if (!(geometryShaderPath.empty() && geometry_code.empty()) && geomID_sptr == 0)
        {   
            geometryShader = glCreateShader(GL_GEOMETRY_SHADER);
            geomID_sptr = std::shared_ptr < GLuint > ( 
                        new GLuint (geometryShader),
                        [] (GLuint *p) {
                            glDeleteShader(*p);
                            delete p;
                        }
                        );
        }


        if (!(tessellationControlShaderPath.empty() && tessellation_control_code.empty()) && tessContID_sptr == 0)
        {   
            tessellationControlShader = glCreateShader(GL_TESS_CONTROL_SHADER);
            tessContID_sptr = std::shared_ptr < GLuint > ( 
                        new GLuint (tessellationControlShader),
                        [] (GLuint *p) {
                            glDeleteShader(*p);
                            delete p;
                        }
                    );
        }

        if (!(tessellationEvaluationShaderPath.empty() && tessellation_evaluation_code.empty()) && tessEvalID_sptr == 0)
        {   
            tessellationEvaluationShader = glCreateShader(GL_TESS_EVALUATION_SHADER);
            tessEvalID_sptr = std::shared_ptr < GLuint > ( 
                        new GLuint (tessellationEvaluationShader),
                        [] (GLuint *p) {
                            glDeleteShader(*p);
                            delete p;
                        }
                    );
        }
        
        
        if (!(computeShaderPath.empty() && compute_shader_code.empty()) && computeID_sptr == 0)
        {   
            computeShader = glCreateShader(GL_COMPUTE_SHADER);
            computeID_sptr = std::shared_ptr < GLuint > ( 
                        new GLuint (computeShader),
                        [] (GLuint *p) {
                            glDeleteShader(*p);
                            delete p;
                        }
                    );
        }


        #ifdef TUCANODEBUG
        Tucano::Misc::errorCheckFunc(__FILE__, __LINE__, "mesh constructor");
        #endif

    }

    Shader (string name, string vertex_shader_path, string fragment_shader_path, string geometry_shader_path = "", string tessellation_evaluation_shader_path = "", string tessellation_control_shader_path = "")
    {
        shaderName = name;
        vertexShaderPath = vertex_shader_path;
        tessellationControlShaderPath = tessellation_control_shader_path;
        tessellationEvaluationShaderPath = tessellation_evaluation_shader_path;
        geometryShaderPath = geometry_shader_path;
        fragmentShaderPath = fragment_shader_path;

        createProgramID();
    }

    Shader (string name, string shader_dir)
        {
                load (name, shader_dir);
        createProgramID();
    }


    Shader() 
    {
        createProgramID();
    }

    /*Shader (string name, string compute_shader_path)
    {
        shaderName = name;
        computeShaderPath = compute_shader_path;
        createProgramID();
    }*/

   /* ~Shader (void)
    {
        deleteShaders();

        #ifdef TUCANODEBUG
        Misc::errorCheckFunc(__FILE__, __LINE__, "Shader destructor");
        #endif
    }*/

        void setShaderName (string name)
        {
                shaderName = name;
        }

    string getShaderName (void)
    {
        return shaderName;
    }

    GLuint getShaderProgram (void)
    {
        if (programID_sptr)
            return *programID_sptr;
        return 0;
    }

    GLuint getFragmentShader (void)
    {
        if (fragID_sptr)
            return *fragID_sptr;
        return 0;
    }

    GLuint getVertexShader (void)
    {
        if (vertexID_sptr)
            return *vertexID_sptr;
        return 0;
    }

    GLuint getGeometryShader (void)
    {
        if (geomID_sptr)
            return *geomID_sptr;
        return 0;
    }

    GLuint getTessellationControlShader (void)
    {
        if (tessContID_sptr)
            return *tessContID_sptr;
        return 0;
    }


    GLuint getTessellationEvaluationShader (void)
    {
        if (tessEvalID_sptr)
            return *tessEvalID_sptr;
        return 0;
    }



    GLuint getComputeShader (void) 
    {
        if (computeID_sptr)
            return *computeID_sptr;
        return 0;
    }


public:

 
        void load (string name, string shader_dir = "")
        {
            shaderName = name;

        bool found = false;

        //Vertex:
        string vs_name = shader_dir + name + ".vert";
        ifstream vertex_file(vs_name.c_str());
        if (vertex_file.good())
        {
            vertexShaderPath = vs_name;
            found = true;
        }

        //Tessellation Control:
        string tesc_name = shader_dir + name + ".tesc";
        ifstream tesc_file(tesc_name.c_str());
        if (tesc_file.good())
        {
            tessellationControlShaderPath = tesc_name;
            found = true;
        }

        //Tessellation Evaluation:
        string tese_name = shader_dir + name + ".tese";
        ifstream tese_file(tese_name.c_str());
        if (tese_file.good())
        {
            tessellationEvaluationShaderPath = tese_name;
            found = true;
        }

        //Geometry:
        string gs_name = shader_dir + name + ".geom";
        ifstream geom_file(gs_name.c_str());
        if (geom_file.good())
        {
            geometryShaderPath = gs_name;
            found = true;
        }

        //Fragment:
        string fs_name = shader_dir + name + ".frag";
        ifstream fragment_file(fs_name.c_str());
        if (fragment_file.good())
        {
            fragmentShaderPath = fs_name;
            found = true;
        }

        //Compute:
        string cs_name = shader_dir + name + ".comp";
        ifstream comp_file(cs_name.c_str());
        if (comp_file.good())
        {
            computeShaderPath = cs_name;
            found = true;
        }

        // if no shader was found, emit an warning
        if (!found)
        {
            std::cerr << "Warning: no shader " << name.c_str() << " file found in directory : " << shader_dir.c_str() << std::endl;
        }

        }


    void linkProgram (void)
    {

        glLinkProgram(*programID_sptr);

        GLint result = GL_FALSE;
        glGetProgramiv(*programID_sptr, GL_LINK_STATUS, &result);
        if (result != GL_TRUE)
        {
            std::cerr << "Error linking program : " << shaderName << std::endl;
            GLchar errorLog[1024] = {0};
            glGetProgramInfoLog(*programID_sptr, 1024, NULL, errorLog);
            fprintf(stdout, "%s", &errorLog[0]);
            std::cerr << std::endl;
        }
        #ifdef TUCANODEBUG
        else
        {
            std::cout << " Successfully linked : " << shaderName << std::endl << std::endl;
        }
        #endif
    }


    void initializeTF (int size, const char** varlist, GLenum buffer_mode = GL_INTERLEAVED_ATTRIBS)
    {
        createShaders();
        if(!vertexShaderPath.empty())
        {
            readVertexCode();
            // tessellation control shader needs a vertex shader
            if (!tessellationControlShaderPath.empty())
            {
                readTessellationControlCode();
            }
            // tessellation evaluation shader needs a vertex shader
            if (!tessellationEvaluationShaderPath.empty())
            {
                readTessellationEvaluationCode();
            }
            // geom shader needs a vertex shader
            if(!geometryShaderPath.empty())
            {
                readGeometryCode();
            }
        }
        if(!fragmentShaderPath.empty())
        {
            readFragmentCode();
        }
        if(!computeShaderPath.empty())
        {
            readComputeShaderCode();
        }

        glTransformFeedbackVaryings(*programID_sptr, size, varlist, buffer_mode);

        linkProgram();

        #ifdef TUCANODEBUG
        Misc::errorCheckFunc(__FILE__, __LINE__);
        #endif
    }

    void initializeFromStrings (string in_vertex_code, string in_fragment_code, string in_geometry_code = "", string in_tessellation_evaluation_code = "", string in_tessellation_control_code = "")
    {
        vertex_code = in_vertex_code;
        fragment_code = in_fragment_code;
        geometry_code = in_geometry_code;
        tessellation_evaluation_code = in_tessellation_evaluation_code;
        tessellation_control_code = in_tessellation_control_code;

        createShaders();

        if (vertex_code.empty())
        {
            std::cerr << "warning: " << shaderName.c_str() << " : empty vertex string code!" << std::endl;
        }
        else
        {
            setVertexShader(vertex_code);
            // tessellation control shader is optional, but needs needs a vertex shader
            if (!tessellationControlShaderPath.empty())
            {
                setTessellationControlShader(tessellation_control_code);
            }
            // tessellation evaluation shader is optional, but needs a vertex shader
            if (!tessellationEvaluationShaderPath.empty())
            {
                setTessellationEvaluationShader(tessellation_evaluation_code);
            }
            // geometry shader is optional, but need a vertex shader if is set
            if (!geometry_code.empty())
            {
                setGeometryShader(geometry_code);
            }
        }
        if (fragment_code.empty())
        {
            std::cerr << "warning: " << shaderName.c_str() << " : empty fragment string code!" << std::endl;
        }
        else
        {
            setFragmentShader(fragment_code);
        }

        linkProgram();

        #ifdef TUCANODEBUG
        Misc::errorCheckFunc(__FILE__, __LINE__);
        #endif
    }

    void initialize (void)
    {
        createShaders();
        if(!vertexShaderPath.empty())
        {
            readVertexCode();
            // tessellation control shader needs a vertex shader
            if (!tessellationControlShaderPath.empty())
            {
                readTessellationControlCode();
            }
            // tessellation evaluation shader needs a vertex shader
            if (!tessellationEvaluationShaderPath.empty())
            {
                readTessellationEvaluationCode();
            }
            // geom shader needs a vertex shader
            if(!geometryShaderPath.empty()) {
                readGeometryCode();
            }
        }
        if(!fragmentShaderPath.empty())
        {
            readFragmentCode();
        }
        if(!computeShaderPath.empty())
        {
            readComputeShaderCode();
        }        

        linkProgram();

        #ifdef TUCANODEBUG
        Misc::errorCheckFunc(__FILE__, __LINE__);
        #endif
    }

    void setVertexShader (string &vertexShaderCode)
    {
        GLint result = GL_FALSE;
        int infoLogLength;

        char const * vertexSourcePointer = vertexShaderCode.c_str();
        glShaderSource(*vertexID_sptr, 1, &vertexSourcePointer , NULL);
        glCompileShader(*vertexID_sptr);

        // Check Vertex Shader
        glGetShaderiv(*vertexID_sptr, GL_COMPILE_STATUS, &result);
        if (result != GL_TRUE)
        {
            // if an error is found, print the log (even if not in debug mode)
            std::cerr << "Erro compiling vertex shader: " << vertexShaderPath << std::endl;
            glGetShaderiv(*vertexID_sptr, GL_INFO_LOG_LENGTH, &infoLogLength);
            char * vertexShaderErrorMessage = new char[infoLogLength];
            glGetShaderInfoLog(*vertexID_sptr, infoLogLength, NULL, &vertexShaderErrorMessage[0]);
            fprintf(stdout, "\n%s", &vertexShaderErrorMessage[0]);
            delete [] vertexShaderErrorMessage;
        }
        #ifdef TUCANODEBUG
        else
        {
            if (vertexShaderPath.empty())
            {
                std::cout << "Compiled vertex shader from string without errors : " << shaderName.c_str() << std::endl;
            }
            else
            {
                std::cout << "Compiled vertex shader without errors : " << vertexShaderPath << std::endl;
            }
        }
        #endif

        glAttachShader(*programID_sptr, *vertexID_sptr);

        #ifdef TUCANODEBUG
        Misc::errorCheckFunc(__FILE__, __LINE__, "error loading vertex shader code");
        #endif

    }

    void readVertexCode (void)
    {
        // Read the Vertex Shader code from the file
        string vertexShaderCode;

        ifstream vertexShaderStream(vertexShaderPath.c_str(), std::ios::in);

        if(vertexShaderStream.is_open())
        {
            string line = "";
            while(getline(vertexShaderStream, line))
            {
                vertexShaderCode += "\n" + line;
            }
            vertexShaderStream.close();
        }
        else
        {
            std::cout << "warning: no vertex shader file found : " << vertexShaderPath << std::endl;
        }

        setVertexShader(vertexShaderCode);
        vertex_code = vertexShaderCode;
    }

    void setTessellationControlShader(string &tessellationControlCode)
    {
        GLint result = GL_FALSE;
        int infoLogLength;

        char const * tessellationControlSourcePointer = tessellationControlCode.c_str();
        glShaderSource(*tessContID_sptr, 1, &tessellationControlSourcePointer , NULL);
        glCompileShader(*tessContID_sptr);

        // Check Vertex Shader
        glGetShaderiv(*tessContID_sptr, GL_COMPILE_STATUS, &result);
        if (result != GL_TRUE)
        {
            // if an error is found, print the log (even if not in debug mode)
            std::cerr << "Erro compiling tessellation evaluation shader: " << tessellationControlShaderPath << std::endl;
            glGetShaderiv(*tessContID_sptr, GL_INFO_LOG_LENGTH, &infoLogLength);
            char * tessellationControlShaderErrorMessage = new char[infoLogLength];
            glGetShaderInfoLog(*tessContID_sptr, infoLogLength, NULL, &tessellationControlShaderErrorMessage[0]);
            fprintf(stdout, "\n%s", &tessellationControlShaderErrorMessage[0]);
            delete [] tessellationControlShaderErrorMessage;
        }
        #ifdef TUCANODEBUG
        else
        {
            if (tessellationControlShaderPath.empty())
            {
                std::cout << "Compiled tessellation control shader from string without errors : " << shaderName.c_str() << std::endl;
            }
            else
            {
                std::cout << "Compiled tessellation control shader without errors : " << tessellationControlShaderPath << std::endl;
            }
        }
        #endif

        glAttachShader(*programID_sptr, *tessContID_sptr);

        #ifdef TUCANODEBUG
        Misc::errorCheckFunc(__FILE__, __LINE__, "error loading tessellation control shader code");
        #endif
    }

    void readTessellationControlCode(void)
    {
        // Read the tessellation control Shader code from the file
        string tessellationControlShaderCode;

        ifstream tessellationControlShaderStream(tessellationControlShaderPath.c_str(), std::ios::in);
        if(tessellationControlShaderStream.is_open())
        {
            string line = "";
            while(getline(tessellationControlShaderStream, line))
            {
                tessellationControlShaderCode += "\n" + line;
            }
            tessellationControlShaderStream.close();
        }
        else
        {
            std::cout << "warning: no tessellation control shader file found : " << tessellationControlShaderPath << std::endl;
        }

        setTessellationControlShader(tessellationControlShaderCode);
        tessellation_control_code =  tessellationControlShaderCode;
    }

    void setTessellationEvaluationShader(string &tessellationEvaluationCode)
    {
        GLint result = GL_FALSE;
        int infoLogLength;

        char const * tessellationEvaluationSourcePointer = tessellationEvaluationCode.c_str();
        glShaderSource(*tessEvalID_sptr, 1, &tessellationEvaluationSourcePointer , NULL);
        glCompileShader(*tessEvalID_sptr);

        // Check Vertex Shader
        glGetShaderiv(*tessEvalID_sptr, GL_COMPILE_STATUS, &result);
        if (result != GL_TRUE)
        {
            // if an error is found, print the log (even if not in debug mode)
            std::cerr << "Erro compiling tessellation evaluation shader: " << tessellationEvaluationShaderPath << std::endl;
            glGetShaderiv(*tessEvalID_sptr, GL_INFO_LOG_LENGTH, &infoLogLength);
            char * tessellationEvaluationShaderErrorMessage = new char[infoLogLength];
            glGetShaderInfoLog(*tessEvalID_sptr, infoLogLength, NULL, &tessellationEvaluationShaderErrorMessage[0]);
            fprintf(stdout, "\n%s", &tessellationEvaluationShaderErrorMessage[0]);
            delete [] tessellationEvaluationShaderErrorMessage;
        }
        #ifdef TUCANODEBUG
        else
        {
            if (tessellationEvaluationShaderPath.empty())
            {
                std::cout << "Compiled tessellation evaluation shader from string without errors : " << shaderName.c_str() << std::endl;
            }
            else
            {
                std::cout << "Compiled tessellation evaluation shader without errors : " << tessellationEvaluationShaderPath << std::endl;
            }
        }
        #endif

        glAttachShader(*programID_sptr, *tessEvalID_sptr);

        #ifdef TUCANODEBUG
        Misc::errorCheckFunc(__FILE__, __LINE__, "error loading tessellation evaluation shader code");
        #endif
    }

    void readTessellationEvaluationCode(void)
    {
        // Read the Vertex Shader code from the file
        string tessellationEvaluationShaderCode;

        ifstream tessellationEvaluationShaderStream(tessellationEvaluationShaderPath.c_str(), std::ios::in);

        if(tessellationEvaluationShaderStream.is_open())
        {
            string line = "";
            while(getline(tessellationEvaluationShaderStream, line))
            {
                tessellationEvaluationShaderCode += "\n" + line;
            }
            tessellationEvaluationShaderStream.close();
        }
        else
        {
            std::cout << "warning: no tessellation evaluation shader file found : " << tessellationEvaluationShaderPath << std::endl;
        }

        setTessellationEvaluationShader(tessellationEvaluationShaderCode);
        tessellation_evaluation_code = tessellationEvaluationShaderCode;
    }

    void setGeometryShader(string &geometryShaderCode)
    {
        GLint result = GL_FALSE;
        int infoLogLength;

        char const * geometrySourcePointer = geometryShaderCode.c_str();
        glShaderSource(*geomID_sptr, 1, &geometrySourcePointer , NULL);
        glCompileShader(geometryShader);

        // Check Geometry Shader
        glGetShaderiv(*geomID_sptr, GL_COMPILE_STATUS, &result);
        if (result != GL_TRUE)
        {
            // if an error is found, print the log (even if not in debug mode)
            std::cerr << "Erro compiling geometry shader: " << geometryShaderPath << std::endl;
            glGetShaderiv(*geomID_sptr, GL_INFO_LOG_LENGTH, &infoLogLength);
            char * geometryShaderErrorMessage = new char[infoLogLength];
            glGetShaderInfoLog(*geomID_sptr, infoLogLength, NULL, &geometryShaderErrorMessage[0]);
            fprintf(stdout, "\n%s", &geometryShaderErrorMessage[0]);
            delete [] geometryShaderErrorMessage;
        }
        #ifdef TUCANODEBUG
        else
        {
            if (geometryShaderPath.empty())
            {
                std::cout << "Compiled geometry shader from string without errors : " << shaderName.c_str() << std::endl;
            }
            else
            {
                std::cout << "Compiled geometry shader without errors : " << geometryShaderPath << std::endl;
            }
        }
        #endif

        glAttachShader(*programID_sptr, *geomID_sptr);

        #ifdef TUCANODEBUG
        Misc::errorCheckFunc(__FILE__, __LINE__, "error loading geometry shader code");
        #endif

    }

    void readGeometryCode (void)
    {
        // Read the Geometry Shader code from the file
        string geometryShaderCode;

        ifstream geometryShaderStream(geometryShaderPath.c_str(), std::ios::in);

        if(geometryShaderStream.is_open())
        {
            string line = "";
            while(getline(geometryShaderStream, line))
            {
                geometryShaderCode += "\n" + line;
            }
            geometryShaderStream.close();
        }
        else
        {
            std::cerr << "warning: no geom shader found : " << geometryShaderPath << std::endl;
        }

        setGeometryShader(geometryShaderCode);
        geometry_code = geometryShaderCode;
    }

    void setFragmentShader (string& fragmentShaderCode)
    {
        GLint result = GL_FALSE;
        int infoLogLength;

        char const * fragmentSourcePointer = fragmentShaderCode.c_str();
        glShaderSource(*fragID_sptr, 1, &fragmentSourcePointer , NULL);
        glCompileShader(fragmentShader);

        // Check Fragment Shader
        glGetShaderiv(*fragID_sptr, GL_COMPILE_STATUS, &result);
        if (result != GL_TRUE)
        {
            std::cerr << "Erro compiling fragment shader: " << fragmentShaderPath << std::endl;
            glGetShaderiv(*fragID_sptr, GL_INFO_LOG_LENGTH, &infoLogLength);
            char * fragmentShaderErrorMessage = new char[infoLogLength];
            glGetShaderInfoLog(*fragID_sptr, infoLogLength, NULL, &fragmentShaderErrorMessage[0]);
            fprintf(stdout, "\n%s", &fragmentShaderErrorMessage[0]);
            delete [] fragmentShaderErrorMessage;
        }
        #ifdef TUCANODEBUG
        else
        {
            if (fragmentShaderPath.empty())
            {
                std::cout << "Compiled fragment shader from string without errors : " << shaderName.c_str() << std::endl;
            }
            else
            {
                std::cout << "Compiled fragment shader without errors : " << fragmentShaderPath << std::endl;
            }
        }
        #endif

        glAttachShader(*programID_sptr, *fragID_sptr);

        #ifdef TUCANODEBUG
        Misc::errorCheckFunc(__FILE__, __LINE__, "error loading fragment shader code");
        #endif

    }

    void readFragmentCode (void)
    {
        // Read the Fragment Shader code from the file
        string fragmentShaderCode;
        ifstream fragmentShaderStream(fragmentShaderPath.c_str(), std::ios::in);
        if(fragmentShaderStream.is_open())
        {
            string line = "";
            while(getline(fragmentShaderStream, line))
            {
                fragmentShaderCode += "\n" + line;
            }
            fragmentShaderStream.close();
        }
        else
        {
            std::cerr << "warning: no fragment shader found : " << fragmentShaderPath << std::endl;
        }

        setFragmentShader(fragmentShaderCode);
        fragment_code = fragmentShaderCode;
    }


    void setComputeShader (string& computeShaderCode)
    {
        GLint result = GL_FALSE;
        int infoLogLength;

        char const * computeSourcePointer = computeShaderCode.c_str();
        glShaderSource(*computeID_sptr, 1, &computeSourcePointer , NULL);
        glCompileShader(*computeID_sptr);

        // Check Compute Shader
        glGetShaderiv(*computeID_sptr, GL_COMPILE_STATUS, &result);
        if (result != GL_TRUE)
        {
            std::cerr << "Erro compiling compute shader: " << computeShaderPath << std::endl;
            glGetShaderiv(*computeID_sptr, GL_INFO_LOG_LENGTH, &infoLogLength);
            char * computeShaderErrorMessage = new char[infoLogLength];
            glGetShaderInfoLog(*computeID_sptr, infoLogLength, NULL, &computeShaderErrorMessage[0]);
            fprintf(stdout, "\n%s", &computeShaderErrorMessage[0]);
            delete [] computeShaderErrorMessage;
        }
        #ifdef TUCANODEBUG
        else
        {
            if (computeShaderPath.empty())
            {
                std::cout << "Compiled compute shader from string without errors : " << shaderName.c_str() << std::endl;
            }
            else
            {
                std::cout << "Compiled compute shader without errors : " << computeShaderPath << std::endl;
            }
        }
        #endif

        glAttachShader(*programID_sptr, *computeID_sptr);

        #ifdef TUCANODEBUG
        Misc::errorCheckFunc(__FILE__, __LINE__, "error loading compute shader code");
        #endif
    }

    void readComputeShaderCode (void)
    {
        string computeShaderCode;
        ifstream computeShaderStream(computeShaderPath.c_str(), std::ios::in);
        if(computeShaderStream.is_open())
        {
            string line = "";
            while(getline(computeShaderStream, line))
            {
                computeShaderCode += "\n" + line;
            }
            computeShaderStream.close();
        }
        else
        {
            std::cerr << "warning: no compute shader found : " << computeShaderPath << std::endl;
        }

        setComputeShader(computeShaderCode);
        compute_shader_code = computeShaderCode;

    }


    void reloadShaders (void)
    {

        #ifdef TUCANODEBUG
        std::cout << "reloading shaders" << std::endl;
        #endif

        if(vertexID_sptr)
        {
            glDetachShader(*programID_sptr, *vertexID_sptr);
            readVertexCode();
        }
        if (tessContID_sptr)
        {
            glDetachShader(*programID_sptr, *tessContID_sptr);
            readTessellationControlCode();
        }
        if (tessEvalID_sptr)
        {
            glDetachShader(*programID_sptr, *tessEvalID_sptr);
            readTessellationEvaluationCode();
        }
        if(geomID_sptr)
        {
            glDetachShader(*programID_sptr, *geomID_sptr);
            readGeometryCode();
        }
        if(fragID_sptr)
        {
            glDetachShader(*programID_sptr, *fragID_sptr);
            readFragmentCode();
        }
        if(computeID_sptr)
        {
            glDetachShader(*programID_sptr, *computeID_sptr);
            readComputeShaderCode();
        }

        linkProgram();

        #ifdef TUCANODEBUG
        Misc::errorCheckFunc(__FILE__, __LINE__);
        #endif
    }

    void bind (void)
    {
        glUseProgram(*programID_sptr);
    }

    void unbind (void)
    {
        glUseProgram(0);
    }

    /*void deleteShaders (void)
    {
        glDetachShader(*programID_sptr, fragmentShader);
        glDetachShader(*programID_sptr, vertexShader);
        glDeleteShader(fragmentShader);
        glDeleteShader(vertexShader);
        glDeleteProgram(*programID_sptr);
    }*/

        void getActiveAttributes( vector< string > &attribs )
        {
                int maxlength = 0;
                int numattribs = 0;

                glGetProgramiv (*programID_sptr, GL_ACTIVE_ATTRIBUTES, &numattribs);
                glGetProgramiv (*programID_sptr, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, &maxlength);

                int length = 0;
                int size = 0;
                GLuint type = 0;
                char* name = new char[maxlength];
                for (int i = 0; i < numattribs; ++i)
                {
                        glGetActiveAttrib(*programID_sptr, i, maxlength, &length, &size, &type, name);
                        attribs.push_back(name);
                }
        delete [] name;
        }

    GLint getUniformLocation (const GLchar* name) const
    {
        return glGetUniformLocation(*programID_sptr, name);
    }

    GLint getAttributeLocation (const GLchar* name) const
    {
        return glGetAttribLocation(*programID_sptr, name);
    }

    //============================Uniforms Setters==========================================================


    //============================ Integer ==========================================================

    void setUniform (GLint location, GLint a, GLint b, GLint c, GLint d)
    {
        glUniform4i(location, a, b, c, d);
    }

    void setUniform (GLint location, GLint a, GLint b, GLint c)
    {
        glUniform3i(location, a, b, c);
    }

    void setUniform (GLint location, GLint a, GLint b)
    {
        glUniform2i(location, a, b);
    }

    void setUniform (GLint location, GLint a)
    {
        glUniform1i(location, a);
    }

    void setUniform (const GLchar* name, GLint a, GLint b, GLint c, GLint d)
    {
        GLint location = getUniformLocation(name);
        setUniform(location, a, b, c, d);
    }

    void setUniform (const GLchar* name, GLint a, GLint b, GLint c)
    {
        GLint location = getUniformLocation(name);
        setUniform(location, a, b, c);
    }

    void setUniform (const GLchar* name, GLint a, GLint b)
    {
        GLint location = getUniformLocation(name);
        setUniform(location, a, b);
    }

    void setUniform (const GLchar* name, GLint a)
    {
        GLint location = getUniformLocation(name);
        setUniform(location, a);
    }

    void setUniform (GLint location, const Eigen::Vector4i &vec)
    {
        glUniform4i(location, vec[0], vec[1], vec[2], vec[3]);
    }

    void setUniform (GLint location, const Eigen::Vector3i &vec)
    {
        glUniform3i(location, vec[0], vec[1], vec[2]);
    }

    void setUniform (GLint location, const Eigen::Vector2i &vec)
    {
        glUniform2i(location, vec[0], vec[1]);
    }

    void setUniform (const GLchar* name, const Eigen::Vector4i &vec)
    {
        GLint location = getUniformLocation(name);
        setUniform(location, vec);
    }

    void setUniform (const GLchar* name, const Eigen::Vector3i &vec)
    {
        GLint location = getUniformLocation(name);
        setUniform(location, vec);
    }

    void setUniform (const GLchar* name, const Eigen::Vector2i &vec)
    {
        GLint location = getUniformLocation(name);
        setUniform(location, vec);
    }

    //============================ Float ==========================================================


    void setUniform (GLint location, GLfloat a, GLfloat b, GLfloat c, GLfloat d)
    {
        glUniform4f(location, a, b, c, d);
    }

    void setUniform (GLint location, GLfloat a, GLfloat b, GLfloat c)
    {
        glUniform3f(location, a, b, c);
    }

    void setUniform (GLint location, GLfloat a, GLfloat b)
    {
        glUniform2f(location, a, b);
    }

    void setUniform (GLint location, GLfloat a)
    {
        glUniform1f(location, a);
    }

    void setUniform (const GLchar* name, GLfloat a, GLfloat b, GLfloat c, GLfloat d)
    {
        GLint location = getUniformLocation(name);
        setUniform(location, a, b, c, d);
    }

    void setUniform (const GLchar* name, GLfloat a, GLfloat b, GLfloat c)
    {
        GLint location = getUniformLocation(name);
        setUniform(location, a, b, c);
    }

    void setUniform (const GLchar* name, GLfloat a, GLfloat b)
    {
        GLint location = getUniformLocation(name);
        setUniform(location, a, b);
    }

    void setUniform (const GLchar* name, GLfloat a)
    {
        GLint location = getUniformLocation(name);
        setUniform(location, a);
    }

    void setUniform (GLint location, const Eigen::Vector4f &vec)
    {
        glUniform4f(location, vec[0], vec[1], vec[2], vec[3]);
    }

    void setUniform (GLint location, const Eigen::Vector3f &vec)
    {
        glUniform3f(location, vec[0], vec[1], vec[2]);
    }

    void setUniform (GLint location, const Eigen::Vector2f &vec)
    {
        glUniform2f(location, vec[0], vec[1]);
    }

    void setUniform (const GLchar* name, const Eigen::Vector4f &vec)
    {
        GLint location = getUniformLocation(name);
        setUniform(location, vec);
    }

    void setUniform (const GLchar* name, const Eigen::Vector3f &vec)
    {
        GLint location = getUniformLocation(name);
        setUniform(location, vec);
    }

    void setUniform (const GLchar* name, const Eigen::Vector2f &vec)
    {
        GLint location = getUniformLocation(name);
        setUniform(location, vec);
    }

    //============================ Double ==========================================================

    void setUniform (GLint location, GLdouble a, GLdouble b, GLdouble c, GLdouble d)
    {
        glUniform4f(location, (GLfloat)a, (GLfloat)b, (GLfloat)c, (GLfloat)d);
    }

    void setUniform (GLint location, GLdouble a, GLdouble b, GLdouble c)
    {
        glUniform3f(location, (GLfloat)a, (GLfloat)b, (GLfloat)c);
    }

    void setUniform (GLint location, GLdouble a, GLdouble b)
    {
        glUniform2f(location, (GLfloat)a, (GLfloat)b);
    }

    void setUniform (GLint location, GLdouble a)
    {
        glUniform1f(location, (GLfloat)a);
    }

    void setUniform (const GLchar* name, GLdouble a, GLdouble b, GLdouble c, GLdouble d)
    {
        GLint location = getUniformLocation(name);
        setUniform(location, a, b, c, d);
    }

    void setUniform (const GLchar* name, GLdouble a, GLdouble b, GLdouble c)
    {
        GLint location = getUniformLocation(name);
        setUniform(location, a, b, c);
    }

    void setUniform (const GLchar* name, GLdouble a, GLdouble b)
    {
        GLint location = getUniformLocation(name);
        setUniform(location, a, b);
    }
    void setUniform (const GLchar* name, GLdouble a)
    {
        GLint location = getUniformLocation(name);
        setUniform(location, a);
    }


    void setUniform (GLint location, const Eigen::Vector4d vec)
    {
        glUniform4f(location, (GLfloat)vec[0], (GLfloat)vec[1], (GLfloat)vec[2], (GLfloat)vec[3]);
    }

    void setUniform (GLint location, const Eigen::Vector3d vec)
    {
        glUniform3f(location, (GLfloat)vec[0], (GLfloat)vec[1], (GLfloat)vec[2]);
    }

    void setUniform (GLint location, const Eigen::Vector2d vec)
    {
        glUniform2f(location, (GLfloat)vec[0], (GLfloat)vec[1]);
    }

    void setUniform (const GLchar* name, const Eigen::Vector4d vec)
    {
        GLint location = getUniformLocation(name);
        setUniform(location, vec);
    }

    void setUniform (const GLchar* name, const Eigen::Vector3d vec)
    {
        GLint location = getUniformLocation(name);
        setUniform(location, vec);
    }

    void setUniform (const GLchar* name, const Eigen::Vector2d vec)
    {
        GLint location = getUniformLocation(name);
        setUniform(location, vec);
    }


    //============================ Vector from Array ==========================================================

    void setUniform (GLint location, const GLint* v, GLuint nvalues, GLsizei count = 1)
    {
        switch (nvalues)
        {
            case 1: glUniform1iv(location, count, v); break;
            case 2: glUniform2iv(location, count, v); break;
            case 3: glUniform3iv(location, count, v); break;
            case 4: glUniform4iv(location, count, v); break;
        }
    }
    void setUniform (GLint location, const GLfloat* v, GLuint nvalues, GLsizei count = 1)
    {
        switch (nvalues)
        {
            case 1: glUniform1fv(location, count, v); break;
            case 2: glUniform2fv(location, count, v); break;
            case 3: glUniform3fv(location, count, v); break;
            case 4: glUniform4fv(location, count, v); break;
        }
    }

    void setUniform (const GLchar* name, const GLint* v, GLuint nvalues, GLsizei count = 1)
    {
        GLint location = getUniformLocation(name);
        setUniform(location,v,nvalues,count);
    }

    void setUniform (const GLchar* name, const GLfloat* v, GLuint nvalues, GLsizei count = 1)
    {
        GLint location = getUniformLocation(name);
        setUniform(location, v, nvalues, count);
    }


    //============================ Matrix ==========================================================

    void setUniform (GLint location, const GLfloat* m, GLuint dim, GLboolean transpose = GL_FALSE, GLsizei count = 1)
    {
        switch(dim)
        {
            case 2: glUniformMatrix2fv(location, count, transpose, m); break;
            case 3: glUniformMatrix3fv(location, count, transpose, m); break;
            case 4: glUniformMatrix4fv(location, count, transpose, m); break;
        }
    }

    void setUniform (const GLchar* name, const GLfloat* m, GLuint dim, GLboolean transpose = GL_FALSE, GLsizei count = 1)
    {
        GLint location = getUniformLocation(name);
        setUniform(location, m, dim, transpose, count);
    }

    void setUniform (GLint location, const Eigen::Matrix4f &matrix)
    {
        glUniformMatrix4fv(location, 1, GL_FALSE, matrix.data());
    }

    void setUniform (GLint location, const Eigen::Matrix3f &matrix)
    {
        glUniformMatrix3fv(location, 1, GL_FALSE, matrix.data());
    }

    void setUniform (GLint location, const Eigen::Matrix2f &matrix)
    {
        glUniformMatrix2fv(location, 1, GL_FALSE, matrix.data());
    }

    void setUniform (const GLchar* name, const Eigen::Matrix4f &matrix)
    {
        GLint location = getUniformLocation(name);
        setUniform(location, matrix);
    }

    void setUniform (const GLchar* name, const Eigen::Matrix3f &matrix)
    {
        GLint location = getUniformLocation(name);
        setUniform(location, matrix);
    }

    void setUniform (const GLchar* name, const Eigen::Matrix2f &matrix)
    {
        GLint location = getUniformLocation(name);
        setUniform(location, matrix);
    }

    void setUniform (GLint location, const Eigen::Affine3f &affine_matrix)
    {
        glUniformMatrix4fv(location, 1, GL_FALSE, affine_matrix.matrix().data());
    }

    void setUniform (GLint location, const Eigen::Affine2f &affine_matrix)
    {
        glUniformMatrix3fv(location, 1, GL_FALSE, affine_matrix.matrix().data());
    }

    void setUniform (const GLchar* name, const Eigen::Affine3f &affine_matrix)
    {
        GLint location = getUniformLocation(name);
        setUniform(location, affine_matrix);
    }

    void setUniform (const GLchar* name, const Eigen::Affine2f &affine_matrix)
    {
        GLint location = getUniformLocation(name);
        setUniform(location, affine_matrix);
    }


};

}
#endif