text: 
  #include "colors.h"
  #include <glad/glad.h>
  
  #include <string>
  #include <fstream>
  #include <sstream>
  #include <iostream>
  
  class Shader
  {
  public:
      unsigned int ID;
      Shader(const char* vertexPath, const char* fragmentPath)
      {
       
          std::string vertexCode;
          std::string fragmentCode;
          std::ifstream vShaderFile;
          std::ifstream fShaderFile;
  
          vShaderFile.exceptions (std::ifstream::failbit | std::ifstream::badbit);
          fShaderFile.exceptions (std::ifstream::failbit | std::ifstream::badbit);
          try 
          {
              vShaderFile.open(vertexPath);
              fShaderFile.open(fragmentPath);
              std::stringstream vShaderStream, fShaderStream;
              vShaderStream << vShaderFile.rdbuf();
              fShaderStream << fShaderFile.rdbuf();
              vShaderFile.close();
              fShaderFile.close();
              vertexCode   = vShaderStream.str();
              fragmentCode = fShaderStream.str();
          }
          catch (std::ifstream::failure& e)
          {
              std::cout << "ERROR::SHADER::FILE_NOT_SUCCESFULLY_READ" << std::endl;
          }
          const char* vShaderCode = vertexCode.c_str();
          const char * fShaderCode = fragmentCode.c_str();
       
          unsigned int vertex, fragment;
  
          vertex = glCreateShader(GL_VERTEX_SHADER);
          glShaderSource(vertex, 1, &vShaderCode, NULL);
          glCompileShader(vertex);
          checkCompileErrors(vertex, "VERTEX");
  
          fragment = glCreateShader(GL_FRAGMENT_SHADER);
          glShaderSource(fragment, 1, &fShaderCode, NULL);
          glCompileShader(fragment);
          checkCompileErrors(fragment, "FRAGMENT");
  
          ID = glCreateProgram();
          glAttachShader(ID, vertex);
          glAttachShader(ID, fragment);
          glLinkProgram(ID);
          checkCompileErrors(ID, "PROGRAM");
  
          glDeleteShader(vertex);
          glDeleteShader(fragment);
      }
      // activate the shader
      // ------------------------------------------------------------------------
      void use() 
      { 
          glUseProgram(ID); 
      }
      // utility uniform functions
      // ------------------------------------------------------------------------
      void setBool(const std::string &name, bool value) const
      {         
          glUniform1i(glGetUniformLocation(ID, name.c_str()), (int)value); 
      }
      // ------------------------------------------------------------------------
      void setInt(const std::string &name, int value) const
      { 
          glUniform1i(glGetUniformLocation(ID, name.c_str()), value); 
      }
      // ------------------------------------------------------------------------
      void setFloat(const std::string &name, float value) const
      { 
          glUniform1f(glGetUniformLocation(ID, name.c_str()), value); 
      }
      void setColor(const std::string &name, float value1, float value2, float value3, float value4) const{
          glUniform4f(glGetUniformLocation(ID, name.c_str()), value1,value2,value3,value4);
      }
      void setresolution(const std::string &name, int width, int height)const{
          glUniform2f(glGetUniformLocation(ID, name.c_str()),width,height);
      }
  
  private:
      // utility function for checking shader compilation/linking errors.
      // ------------------------------------------------------------------------
      void checkCompileErrors(unsigned int shader, std::string type)
      {
          int success;
          char infoLog[1024];
          if (type != "PROGRAM")
          {
              glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
              if (!success)
              {
                  glGetShaderInfoLog(shader, 1024, NULL, infoLog);
                  std::cout << "ERROR::SHADER_COMPILATION_ERROR of type: " << type << "\n" << infoLog << "\n -- --------------------------------------------------- -- " << std::endl;
              }
          }
          else
          {
              glGetProgramiv(shader, GL_LINK_STATUS, &success);
              if (!success)
              {
                  glGetProgramInfoLog(shader, 1024, NULL, infoLog);
                  std::cout << "ERROR::PROGRAM_LINKING_ERROR of type: " << type << "\n" << infoLog << "\n -- --------------------------------------------------- -- " << std::endl;
              }
          }
      }
  };
  