BaseShader::BaseShader(const char* vShader, const char* fShader) {
	GLint logLength, status;
    GLchar* sourceString = NULL;
    
    GetGLError();
	
	// Create a program object
	mProgram = glCreateProgram();
    
    GetGLError();
    
    if (vShader){
        // Allocate memory for the source string including the version preprocessor information
        sourceString = getShaderString(vShader, "vsh");
        
        GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
        glShaderSource(vertexShader, 1, (const GLchar **)&(sourceString), NULL);
        glCompileShader(vertexShader);
        glGetShaderiv(vertexShader, GL_INFO_LOG_LENGTH, &logLength);
        
        if (logLength > 0)
        {
            GLchar *log = (GLchar*) malloc(logLength);
            glGetShaderInfoLog(vertexShader, logLength, &logLength, log);
            printf("Vtx shader compiled log: %s\n", log);
            free(log);
        }
        
        glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &status);
        if (status == 0)
        {
            printf("Failed to compile vtx shader:\n%s\n", sourceString);
        }
        
        free(sourceString);
        sourceString = NULL;
        
        // Attach the vertex shader to our program
        glAttachShader(mProgram, vertexShader);
        
        // Delete the vertex shader since it is now attached
        // to the program, which will retain a reference to it
        glDeleteShader(vertexShader);
    }
    
    if (fShader){
        // Allocate memory for the source string including the version preprocessor	 information
        sourceString = getShaderString(fShader, "fsh");
        
        GLuint fragShader = glCreateShader(GL_FRAGMENT_SHADER);
        glShaderSource(fragShader, 1, (const GLchar **)&(sourceString), NULL);
        glCompileShader(fragShader);
        glGetShaderiv(fragShader, GL_INFO_LOG_LENGTH, &logLength);
        if (logLength > 0)
        {
            GLchar *log = (GLchar*)malloc(logLength);
            glGetShaderInfoLog(fragShader, logLength, &logLength, log);
            printf("Frag Shader compile log:\n%s\n", log);
            free(log);
        }
        
        glGetShaderiv(fragShader, GL_COMPILE_STATUS, &status);
        if (status == 0)
        {
            printf("Failed to compile frag shader:\n%s\n", sourceString);
        }
        
        free(sourceString);
        sourceString = NULL;
        
        // Attach the fragment shader to our program
        glAttachShader(mProgram, fragShader);
        
        // Delete the fragment shader since it is now attached
        // to the program, which will retain a reference to it
        glDeleteShader(fragShader);
    }
    
   // linkProgram();
}
GLuint LoadShaders(char * vertex_file_path, char * fragment_file_path){
    // Create the shaders
    GLuint VertexShaderID = glCreateShader(GL_VERTEX_SHADER);
    GLuint FragmentShaderID = glCreateShader(GL_FRAGMENT_SHADER);

    char *vertex_shader_string;
    char *fragment_shader_string;
    // Read the Vertex Shader code from the file
    vertex_shader_string = getShaderString(vertex_file_path, 0);
    //printf("vertex_shader_string%s\n", vertex_shader_string);
    // Read the Fragment Shader code from the file
    fragment_shader_string = getShaderString(fragment_file_path, 1);
    //printf("fragment_shader_string %d \n%s", strlen(fragment_shader_string), fragment_shader_string);
    // Compile Vertex Shader
    printf("\nCompiling shader : %s\n", vertex_file_path);
    glShaderSource(VertexShaderID, 1, &vertex_shader_string , NULL);
    glCompileShader(VertexShaderID);

    {
        GLint success;
        glGetShaderiv(VertexShaderID, GL_COMPILE_STATUS, &success);
        if(success == GL_FALSE) {
            char log[1024];
            glGetShaderInfoLog(VertexShaderID, sizeof(log), 0, log);
            printf("vert shader compile info: \n %s \n", log);
            glDeleteShader(VertexShaderID);
            //glDeleteProgram(shader);
            //shader = 0;
            return 1;
        }
    }

    // Compile Fragment Shader
    printf("Compiling shader : %s\n", fragment_file_path);
    char const * FragmentSourcePointer = fragment_shader_string;
    glShaderSource(FragmentShaderID, 1, &fragment_shader_string , NULL);
    glCompileShader(FragmentShaderID);

    {
        GLint success;
        glGetShaderiv(FragmentShaderID, GL_COMPILE_STATUS, &success);
        if(success == GL_FALSE) {
            char log[1024];
            glGetShaderInfoLog(FragmentShaderID, sizeof(log), 0, log);
            printf("fragment shader compile info: \n %s \n", log);
            glDeleteShader(FragmentShaderID);
            //glDeleteProgram(shader);
            //shader = 0;
            return 1;
        }
    }

    // Link the program
    fprintf(stdout, "Linking program\n");
    GLuint ProgramID = glCreateProgram();
    glAttachShader(ProgramID, VertexShaderID);
    glAttachShader(ProgramID, FragmentShaderID);
    glLinkProgram(ProgramID);

    glDeleteShader(VertexShaderID);
    glDeleteShader(FragmentShaderID);

    return ProgramID;
}