Shader Class

headers/shader.hpp

@@ -0,0 +1,22 @@
+#ifndef SHADER_H
+#define SHADER_H
+#include <glad/glad.h>
+#include <string>
+
+class Shader {
+public:
+  Shader(const char *vertexPath, const char *fragmentPath);
+  ~Shader();
+  void use();
+  void setInt(const std::string &name, int value);
+  void setFloat(const std::string &name, float value);
+
+private:
+  unsigned int ID;
+  unsigned int shaderCMPL(GLenum type, const char *src);
+  void shaderERR(unsigned int shader);
+  unsigned int shaderProgramCMPL(const char *vertexSource,
+                                 const char *fragmentSource);
+  void shaderProgramERR(unsigned int shaderProgram);
+};
+#endif

shaders/rgbPulseFrag.glsl

@@ -0,0 +1,8 @@
+#version 330 core
+out vec4 FragColor;
+in vec3 color;
+uniform float u_time;
+void main()
+{
+  FragColor = vec4(color,0.0)*(sin(u_time)/2.0+0.5);
+}

shaders/rgbPulseVert.glsl

@@ -0,0 +1,9 @@
+#version 330 core
+layout (location = 0) in vec3 aPos;
+layout (location = 1) in vec3 aColor;
+out vec3 color;
+void main()
+{
+  color = aColor;
+  gl_Position = vec4(aPos.x, aPos.y, aPos.z, 1.0);
+}

src/main.cpp

@@ -3,16 +3,13 @@
 #include <cassert>
 #include <iostream>
 #include <shapes.h>
+#include <shader.hpp>
 
 #define UNUSED(x) (void)(x)
 
 void processInput(GLFWwindow *window);
 void framebuffer_size_callback(GLFWwindow *window, int width, int height);
-unsigned int shaderCMPL(GLenum type, const char *src);
+
-void shaderERR(unsigned int shader);
-unsigned int shaderProgramCMPL(const char *vertexSource,
-                               const char *fragmentSource);
-void shaderProgramERR(unsigned int shaderProgram);
 
 int main(void) {
   int tmp = 0;
@@ -52,9 +49,7 @@ int main(void) {
   glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(sqr_indices), sqr_indices, GL_STATIC_DRAW);
   */
 
-  unsigned int shaderProgram =
+  Shader* shaderProgram = new Shader("./shaders/rgbPulseVert.glsl","./shaders/rgbPulseFrag.glsl");
-      shaderProgramCMPL(rgbVertexShaderSource, rgbPulseFragmentShaderSource);
-  glUseProgram(shaderProgram);
 
   while (!glfwWindowShouldClose(window)) {
     processInput(window);
@@ -62,9 +57,8 @@ int main(void) {
     glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
     glClear(GL_COLOR_BUFFER_BIT);
 
-    glUseProgram(shaderProgram);
+    shaderProgram->use();
-    GLint utime = glGetUniformLocation(shaderProgram, "u_time");
+    shaderProgram->setFloat("u_time",glfwGetTime());
-    glUniform1f(utime, glfwGetTime());
     glBindVertexArray(VAO);
 
     //glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
@@ -74,6 +68,7 @@ int main(void) {
     glfwPollEvents();
   }
 
+  delete(shaderProgram);
   glfwTerminate();
   return 0;
 }
@@ -87,56 +82,3 @@ void framebuffer_size_callback(GLFWwindow *window, int width, int height) {
   UNUSED(window);
   glViewport(0, 0, width, height);
 }
-
-unsigned int shaderCMPL(GLenum type, const char *src) {
-  unsigned int shader;
-  shader = glCreateShader(type);
-  glShaderSource(shader, 1, &src, NULL);
-  glCompileShader(shader);
-  return shader;
-}
-
-void shaderERR(unsigned int shader) {
-  int success;
-  char infoLog[512];
-  glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
-
-  if (!success) {
-    glGetShaderInfoLog(shader, 512, NULL, infoLog);
-    std::cout << "ERROR::SHADER::COMPILATION_FAILED\n" << infoLog << std::endl;
-  }
-}
-
-unsigned int shaderProgramCMPL(const char *vertexSource,
-                               const char *fragmentSource) {
-  unsigned int vertexShader;
-  vertexShader = shaderCMPL(GL_VERTEX_SHADER, vertexSource);
-  shaderERR(vertexShader);
-
-  unsigned int fragmentShader;
-  fragmentShader = shaderCMPL(GL_FRAGMENT_SHADER, fragmentSource);
-  shaderERR(fragmentShader);
-
-  unsigned int shaderProgram;
-  shaderProgram = glCreateProgram();
-
-  glAttachShader(shaderProgram, vertexShader);
-  glAttachShader(shaderProgram, fragmentShader);
-  glLinkProgram(shaderProgram);
-  shaderProgramERR(shaderProgram);
-  glDeleteShader(vertexShader);
-  glDeleteShader(fragmentShader);
-
-  return shaderProgram;
-}
-
-void shaderProgramERR(unsigned int shaderProgram) {
-  int success;
-  char infoLog[512];
-  glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);
-
-  if (!success) {
-    glGetProgramInfoLog(shaderProgram, 512, NULL, infoLog);
-    std::cout << "ERROR::SHADER::PROGRAM::FAILED\n" << infoLog << std::endl;
-  }
-}

src/shader.cpp

@@ -0,0 +1,99 @@
+#include <fstream>
+#include <glad/glad.h>
+#include <iostream>
+#include <shader.hpp>
+#include <sstream>
+#include <string>
+
+/*pub*/
+Shader::Shader(const char *vertexPath, const char *fragmentPath) {
+  std::string vertexCode, fragmentCode;
+  std::ifstream vShaderFile, 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_SUCCESSFULLY_READ: " << e.what()
+              << std::endl;
+  }
+  this->ID = shaderProgramCMPL(vertexCode.c_str(), fragmentCode.c_str());
+}
+
+Shader::~Shader() { glDeleteProgram(ID); }
+
+void Shader::use() { glUseProgram(ID); }
+
+void Shader::setInt(const std::string &name, int value) {
+  glUniform1i(glGetUniformLocation(ID, name.c_str()), value);
+}
+
+void Shader::setFloat(const std::string &name, float value) {
+  glUniform1f(glGetUniformLocation(ID, name.c_str()), value);
+}
+
+/*priv*/
+unsigned int Shader::shaderCMPL(GLenum type, const char *src) {
+  unsigned int shader;
+  shader = glCreateShader(type);
+  glShaderSource(shader, 1, &src, NULL);
+  glCompileShader(shader);
+  return shader;
+}
+
+void Shader::shaderERR(unsigned int shader) {
+  int success;
+  char infoLog[512];
+  glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
+
+  if (!success) {
+    glGetShaderInfoLog(shader, 512, NULL, infoLog);
+    std::cout << "ERROR::SHADER::COMPILATION_FAILED\n" << infoLog << std::endl;
+  }
+}
+
+unsigned int Shader::shaderProgramCMPL(const char *vertexSource,
+                                       const char *fragmentSource) {
+  unsigned int vertexShader;
+  vertexShader = shaderCMPL(GL_VERTEX_SHADER, vertexSource);
+  shaderERR(vertexShader);
+
+  unsigned int fragmentShader;
+  fragmentShader = shaderCMPL(GL_FRAGMENT_SHADER, fragmentSource);
+  shaderERR(fragmentShader);
+
+  unsigned int shaderProgram;
+  shaderProgram = glCreateProgram();
+
+  glAttachShader(shaderProgram, vertexShader);
+  glAttachShader(shaderProgram, fragmentShader);
+  glLinkProgram(shaderProgram);
+  shaderProgramERR(shaderProgram);
+  glDeleteShader(vertexShader);
+  glDeleteShader(fragmentShader);
+
+  return shaderProgram;
+}
+
+void Shader::shaderProgramERR(unsigned int shaderProgram) {
+  int success;
+  char infoLog[512];
+  glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);
+
+  if (!success) {
+    glGetProgramInfoLog(shaderProgram, 512, NULL, infoLog);
+    std::cout << "ERROR::SHADER::PROGRAM::FAILED\n" << infoLog << std::endl;
+  }
+}