ZEN_Shader.cpp

#include <glm/gtc/type_ptr.hpp>
#include <zen/renderer/ZEN_Shader.h>
 
namespace Zen {
  Shader::Shader(const char *vertexPath, const char *fragmentPath) {
    // Read our shaders into the appropriate buffers
    // Create an empty vertex shader handle
    // 1. retrieve the vertex/fragment source code from filePath
    std::string vertexCode;
    std::string fragmentCode;
    std::ifstream vShaderFile;
    std::ifstream fShaderFile;
    // ensure ifstream objects can throw exceptions:
    vShaderFile.exceptions(std::ifstream::failbit | std::ifstream::badbit);
    fShaderFile.exceptions(std::ifstream::failbit | std::ifstream::badbit);
    try {
      // open files
      vShaderFile.open(vertexPath);
      fShaderFile.open(fragmentPath);
      std::stringstream vShaderStream, fShaderStream;
      // read file's buffer contents into streams
      vShaderStream << vShaderFile.rdbuf();
      fShaderStream << fShaderFile.rdbuf();
      // close file handlers
      vShaderFile.close();
      fShaderFile.close();
      // convert stream into string
      vertexCode   = vShaderStream.str();
      fragmentCode = fShaderStream.str();
 
      // ZEN_LOG_DEBUG("{}", vertexCode);
      // ZEN_LOG_DEBUG("{}", fragmentCode);
      // ZEN_LOG_DEBUG("{}", vertexPath);
      // ZEN_LOG_DEBUG("{}", fragmentPath);
    } catch (std::ifstream::failure e) {
      ZEN_LOG_ERROR("ERROR::SHADER::FILE_NOT_SUCCESFULLY_READ");
      throw std::runtime_error("shader file read failed");
    }
    const char *vShaderCode = vertexCode.c_str();
    const char *fShaderCode = fragmentCode.c_str();
 
    uint32_t vertexShader, fragmentShader;
 
    vertexShader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vertexShader, 1, &vShaderCode, nullptr);
 
    // Compile the vertex shader
    glCompileShader(vertexShader);
 
    GLint isCompiled = 0;
    glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &isCompiled);
    if (isCompiled == GL_FALSE) {
      GLint maxLength = 0;
      glGetShaderiv(vertexShader, GL_INFO_LOG_LENGTH, &maxLength);
 
      // The maxLength includes the NULL character
      std::vector<GLchar> infoLog(maxLength);
      glGetShaderInfoLog(vertexShader, maxLength, &maxLength, &infoLog[0]);
 
      // We don't need the shader anymore.
      glDeleteShader(vertexShader);
 
      ZEN_LOG_ERROR("{}", infoLog.data());
      return;
    }
 
    // Create an empty fragment shader handle
    fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fragmentShader, 1, &fShaderCode, nullptr);
 
    // Compile the fragment shader
    glCompileShader(fragmentShader);
 
    glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &isCompiled);
    if (isCompiled == GL_FALSE) {
      GLint maxLength = 0;
      glGetShaderiv(fragmentShader, GL_INFO_LOG_LENGTH, &maxLength);
 
      // The maxLength includes the NULL character
      std::vector<GLchar> infoLog(maxLength);
      glGetShaderInfoLog(fragmentShader, maxLength, &maxLength, &infoLog[0]);
 
      // We don't need the shader anymore.
      glDeleteShader(fragmentShader);
      // Either of them. Don't leak shaders.
      glDeleteShader(vertexShader);
 
      // Use the infoLog as you see fit.
 
      // In this simple program, we'll just leave
      ZEN_LOG_ERROR("{}", infoLog.data());
      return;
    }
 
    // Vertex and fragment shaders are successfully compiled.
    // Now time to link them together into a program.
    // Get a program object.
    m_rendererID   = glCreateProgram();
    GLuint program = m_rendererID;
 
    // Attach our shaders to our program
    glAttachShader(program, vertexShader);
    glAttachShader(program, fragmentShader);
 
    // Link our program
    glLinkProgram(program);
 
    // Note the different functions here: glGetProgram* instead of glGetShader*.
    GLint isLinked = 0;
    glGetProgramiv(program, GL_LINK_STATUS, (int *)&isLinked);
    if (isLinked == GL_FALSE) {
      GLint maxLength = 0;
      glGetProgramiv(program, GL_INFO_LOG_LENGTH, &maxLength);
 
      // The maxLength includes the NULL character
      std::vector<GLchar> infoLog(maxLength);
      glGetProgramInfoLog(program, maxLength, &maxLength, &infoLog[0]);
 
      // We don't need the program anymore.
      glDeleteProgram(program);
      // Don't leak shaders either.
      glDeleteShader(vertexShader);
      glDeleteShader(fragmentShader);
 
      // Use the infoLog as you see fit.
 
      // In this simple program, we'll just leave
      ZEN_LOG_ERROR("{}", infoLog.data());
      return;
    }
 
    // Always detach shaders after a successful link.
    glDetachShader(program, vertexShader);
    glDetachShader(program, fragmentShader);
  }
 
  Shader::~Shader() {
    ZEN_LOG_DEBUG("Shader deconstructed");
    glDeleteProgram(m_rendererID);
  }
 
  void Shader::bind() const {
    // ZEN_LOG_DEBUG("Shader binded");
    glUseProgram(m_rendererID);
  }
 
  void Shader::unBind() const {
    ZEN_LOG_DEBUG("Shader unbinded");
    glUseProgram(0);
  }
 
  void Shader::uploadUniformMat4(const std::string &name, const glm::mat4 &matrix) {
    GLint location = glGetUniformLocation(m_rendererID, name.c_str());
    glUniformMatrix4fv(location, 1, GL_FALSE, glm::value_ptr(matrix));
  }
}; // namespace Zen